{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_set_y = [[0 0 1 0 0 0 0 1 0 0 0 1 0 1 1 0 0 0 0 1 0 0 0 0 1 1 0 1 0 1 0 0 0 0 0 0\n",
      "  0 0 1 0 0 1 1 0 0 0 0 1 0 0 1 0 0 0 1 0 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1\n",
      "  0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 1 1 1 0 0 1 0 0 0 0 1 0 1 0 1 1\n",
      "  1 1 1 1 0 0 0 0 0 1 0 0 0 1 0 0 1 0 1 0 1 1 0 0 0 1 1 1 1 1 0 0 0 0 1 0\n",
      "  1 1 1 0 1 1 0 0 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 0 1 1 1 0 0 1 1 0 1 0 1\n",
      "  0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0]]\n",
      "y = [1], it's a cat` picture\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import scipy\n",
    "from PIL import Image\n",
    "from lr_utils import load_dataset\n",
    "\n",
    "#train_set_x_orig ：保存的是训练集里面的图像数据（本训练集有209张64x64的图像）。\n",
    "#train_set_y_orig ：保存的是训练集的图像对应的分类值（【0 | 1】，0表示不是猫，1表示是猫）。\n",
    "#test_set_x_orig ：保存的是测试集里面的图像数据（本训练集有50张64x64的图像）。\n",
    "#test_set_y_orig ： 保存的是测试集的图像对应的分类值（【0 | 1】，0表示不是猫，1表示是猫）。\n",
    "#classes ： 保存的是以bytes类型保存的两个字符串数据，数据为：[b’non-cat’ b’cat’]。\n",
    "\n",
    "train_set_x_orig,train_set_y,test_set_x_orig,test_set_y,classes = load_dataset()\n",
    "\n",
    "index = 25\n",
    "plt.imshow(train_set_x_orig[index])\n",
    "print(\"train_set_y = \"+ str(train_set_y))  #你也可以看一下训练集里面的标签是什么样的。\n",
    "\n",
    "#打印出当前的训练标签值\n",
    "#使用np.squeeze的目的是压缩维度，【未压缩】train_set_y[:,index]的值为[1] , \n",
    "#【压缩后】np.squeeze(train_set_y[:,index])的值为1\n",
    "#print(\"【使用np.squeeze：\" + str(np.squeeze(train_set_y[:,index])) + \"，不使用np.squeeze： \" + str(train_set_y[:,index]) + \"】\")\n",
    "#只有压缩后的值才能进行解码操作\n",
    "print(\"y = \"+str(train_set_y[:,index])+\", it's a \"+classes[np.squeeze(train_set_y[:,index])].decode(\"utf-8\")+\"` picture\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集的数量：m_train = 209\n",
      "测试集的数量：m_test = 50\n",
      "每张图片的宽/高: num_px = 64\n",
      "每张图片的大小：（64, 64, 3\n",
      "训练集_图片的维数：(209, 64, 64, 3)\n",
      "训练集_标签的维数: (1, 209)\n",
      "测试集_图片的维数：(50, 64, 64, 3)\n",
      "测试集_标签的维数：(1, 50)\n"
     ]
    }
   ],
   "source": [
    "m_train = train_set_y.shape[1] #训练集里图片的数量。\n",
    "m_test = test_set_y.shape[1]   #测试集里图片的数量。\n",
    "num_px = train_set_x_orig.shape[1]  #训练、测试集里面的图片的宽度和高度（均为64x64）。\n",
    "\n",
    "#现在看一看我们加载的东西的具体情况\n",
    "print(\"训练集的数量：m_train = \"+str(m_train))\n",
    "print(\"测试集的数量：m_test = \"+str(m_test))\n",
    "print(\"每张图片的宽/高: num_px = \"+str(num_px))\n",
    "print(\"每张图片的大小：（\" + str(num_px) + \", \" + str(num_px)+\", 3\")\n",
    "print(\"训练集_图片的维数：\" + str(train_set_x_orig.shape))\n",
    "print(\"训练集_标签的维数: \" + str(train_set_y.shape))\n",
    "print(\"测试集_图片的维数：\" + str(test_set_x_orig.shape))\n",
    "print(\"测试集_标签的维数：\" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集降维最后的维度： (12288, 209)\n",
      "训练集_标签的维数： (1, 209)\n",
      "测试集降维之后的维数： (12288, 50)\n",
      "测试集_标签的维数： (1, 50)\n"
     ]
    }
   ],
   "source": [
    "#X_flatten = X.reshape(X.shape [0]，-1).T ＃X.T是X的转置\n",
    "#将训练集的维度降低并转置。\n",
    "train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T\n",
    "#将测试集的维度降低并转置。\n",
    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T\n",
    "print(\"训练集降维最后的维度： \" + str(train_set_x_flatten.shape))\n",
    "print(\"训练集_标签的维数： \" + str(train_set_y.shape))\n",
    "print(\"测试集降维之后的维数： \" + str(test_set_x_flatten.shape))\n",
    "print(\"测试集_标签的维数： \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "#标准化数据集\n",
    "train_set_x = train_set_x_flatten / 255\n",
    "test_set_x = test_set_x_flatten / 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================测试sigmoid=================\n",
      "sigmoid(0) = 0.5\n",
      "sigmoid(9.2) = 0.9998989708060922\n"
     ]
    }
   ],
   "source": [
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    参数：\n",
    "        z - 任何大小的标量或numpy数组\n",
    "        \n",
    "    返回：\n",
    "        s - sigmoid（z）\n",
    "    \"\"\"\n",
    "    s = 1 / (1 + np.exp(-z))\n",
    "    return s\n",
    "\n",
    "#测试sigmoid()\n",
    "print(\"================测试sigmoid=================\")\n",
    "print(\"sigmoid(0) = \" + str(sigmoid(0)))\n",
    "print(\"sigmoid(9.2) = \" + str(sigmoid(9.2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[0.]\n",
      " [0.]]\n",
      "b = 0\n"
     ]
    }
   ],
   "source": [
    "def initialize_with_zeros(dim):\n",
    "    \"\"\"\n",
    "    次函数为w创建一个维度为（dim,1)的0向量，并将b初始化为0\n",
    "    参数：\n",
    "        dim - 我们想要的w矢量的大小（或者这种情况下的参数数量）\n",
    "        \n",
    "    返回：\n",
    "        w - 维度为(dim,1)初始化向量\n",
    "        b - 初始化的标量（对应于偏差）\n",
    "    \"\"\"\n",
    "    w = np.zeros(shape = (dim,1))\n",
    "    b = 0\n",
    "    #使用断言来确保数据是正确的\n",
    "    assert(w.shape == (dim,1)) #w的维度是(dim,1)\n",
    "    assert(isinstance(b,float) or isinstance(b,int)) #b的类型是float或者是int\n",
    "    \n",
    "    return (w,b)\n",
    "dim = 2 \n",
    "w,b = initialize_with_zeros(dim)\n",
    "print(\"w = \" + str(w))\n",
    "print(\"b = \" + str(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=======================测试propagate=======================\n",
      "dw = [[0.99993216]\n",
      " [1.99980262]]\n",
      "db = 0.49993523062470574\n",
      "cost = 6.000064773192205\n"
     ]
    }
   ],
   "source": [
    "def propagate(w,b,X,Y):\n",
    "    \"\"\"\n",
    "    实现前向和后向传播的成本函数及其梯度\n",
    "    参数：\n",
    "        w - 权重，大小不等的数组（num_px * num_px * 3，1）\n",
    "        b - 偏差，一个标量\n",
    "        X - 矩阵类型为（num_px * num_px * 3，训练数量）\n",
    "        Y - 真正的标签矢量（如果非猫则为0，猫则为1），矩阵维度为（1，训练数据数量）\n",
    "    \n",
    "    返回：\n",
    "        cost - 逻辑回归的负对数似然成本\n",
    "        dw   - 相对于w的损失梯度，因此与w形状相同\n",
    "        db   - 相对于b的损失梯度，因此与b形状相同\n",
    "    \"\"\"\n",
    "    m = X.shape[1]\n",
    "    \n",
    "    #正向传播\n",
    "    A = sigmoid(np.dot(w.T,X) + b)  #计算激活值\n",
    "    cost = (-1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1-A))) #计算成本\n",
    "    \n",
    "    #反向传播\n",
    "    dw = (1/m) * np.dot(X, (A-Y).T)\n",
    "    db = (1/m) * np.sum(A-Y)\n",
    "    \n",
    "    #使用断言确保数据正确\n",
    "    assert(dw.shape == w.shape)\n",
    "    assert(db.dtype == float)  #dtype 数组元素的类型\n",
    "    cost = np.squeeze(cost)\n",
    "    assert(cost.shape == ())\n",
    "    \n",
    "    #  创建一个字典，把dw和db保存起来\n",
    "    grads = {\n",
    "        \"dw\": dw,\n",
    "        \"db\": db\n",
    "    }\n",
    "    return (grads,cost)\n",
    "\n",
    "#测试propagate\n",
    "print(\"=======================测试propagate=======================\")\n",
    "#初始化一些参数\n",
    "w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([1,0])\n",
    "grads, cost = propagate(w, b, X, Y)\n",
    "print(\"dw = \" + str(grads[\"dw\"]))\n",
    "print(\"db = \" + str(grads[\"db\"]))\n",
    "print(\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=====================测试optimize======================\n",
      "w = [[0.1124579 ]\n",
      " [0.23106775]]\n",
      "b = 1.5593049248448891\n",
      "dw = [[0.90158428]\n",
      " [1.76250842]]\n",
      "db = 0.4304620716786828\n"
     ]
    }
   ],
   "source": [
    "def optimize(w, b ,X, Y, num_iterations, learning_rate, print_cost = False):\n",
    "    \"\"\"\n",
    "    次函数通过运行梯度下降算法来优化w和b\n",
    "    \n",
    "    参数：\n",
    "        w - 权重，大小不等的数组（num_px * num_px * 3， 1）\n",
    "        b - 偏差，一个标量\n",
    "        X - 维度为（num_px * num_px * 3，训练数据的数量）的数组。\n",
    "        Y - 真正的标量矢量（如果非猫则为0，猫则为1），矩阵维度为（1，训练数据数量）\n",
    "        num_iterations - 优化循环的迭代次数\n",
    "        learning_rate - 梯度下降更新规则的学习率\n",
    "        print_cost - 每100步打印一次损失值\n",
    "        \n",
    "    返回：\n",
    "        params - 包含权重w和偏差b的字典\n",
    "        grads  - 包含权重和偏差相对于成本函数的梯度字典\n",
    "        costs  - 优化期间计算的所有成本列表，将用于绘制学习曲线\n",
    "        \n",
    "    提示：\n",
    "    需要写两个步骤并遍历它们：\n",
    "        1. 计算当前参数的成本和梯度，使用propagate()\n",
    "        2. 使用w和b的梯度下降法更新参数\n",
    "    \"\"\"\n",
    "    \n",
    "    costs = []\n",
    "    for i in range(num_iterations):\n",
    "        grads,cost = propagate(w, b, X, Y)\n",
    "        \n",
    "        dw = grads[\"dw\"]\n",
    "        db = grads[\"db\"]\n",
    "        \n",
    "        w = w - learning_rate * dw\n",
    "        b = b - learning_rate * db\n",
    "        \n",
    "        #记录成本\n",
    "        if i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "            \n",
    "        #打印成本数据\n",
    "        if(print_cost) and (i % 100 == 0):\n",
    "            print(\"迭代次数：%i， 误差值： %f \" % (i,cost))\n",
    "            \n",
    "    params = {\n",
    "         \"w\" : w,\n",
    "         \"b\" : b\n",
    "    }\n",
    "    grads = {\n",
    "         \"dw\": dw,\n",
    "         \"db\": db\n",
    "    }\n",
    "    return (params, grads, costs)\n",
    "    \n",
    "# 测试optimize\n",
    "print(\"=====================测试optimize======================\")\n",
    "w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([1,0])\n",
    "params, grads, costs = optimize(w, b, X, Y, num_iterations=100, learning_rate=0.009,print_cost=False)\n",
    "print(\"w = \" + str(params[\"w\"]))\n",
    "print(\"b = \" + str(params[\"b\"]))\n",
    "print(\"dw = \" + str(grads[\"dw\"]))\n",
    "print(\"db = \" + str(grads[\"db\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=======================测试predict======================\n",
      "predictions = [[1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "def predict(w, b, X):\n",
    "    \"\"\"\n",
    "    使用学习逻辑回归参数logistic(w,b)预测标签是0还是1，分两步：\n",
    "        1. 计算 Yˆ=A=σ(wTX+b)\n",
    "        2. 将a的值变为0（若激活值<= 0.5）或者为1（激活值> 0.5），\n",
    "\n",
    "    \n",
    "    参数：\n",
    "        w - 权重，大小不等的数组（num_px * num_px * 3， 1）\n",
    "        b - 偏差，一个标量\n",
    "        X - 维度为（num_px * num_px * 3，训练数据的数量）的数组\n",
    "        \n",
    "    返回：\n",
    "        Y_prediction - 包含X中所有图片的所有预测[0|1]的一个numpy数组（向量）\n",
    "        \n",
    "    \"\"\"\n",
    "    m = X.shape[1] #图片的数量\n",
    "    Y_prediction = np.zeros((1,m))\n",
    "    w = w.reshape(X.shape[0],1)\n",
    "    \n",
    "    #计算预测猫在图片中出现的概率\n",
    "    A = sigmoid(np.dot(w.T,X) + b)\n",
    "    for i in range(A.shape[1]):\n",
    "        #将概率a [0，i]转换为实际预测p [0，i]\n",
    "        Y_prediction[0,i] = 1 if A[0,i] > 0.5 else 0\n",
    "    \n",
    "    #使用断言\n",
    "    assert(Y_prediction.shape == (1,m))\n",
    "    \n",
    "    return Y_prediction\n",
    "\n",
    "#测试predict\n",
    "print(\"=======================测试predict======================\")\n",
    "w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([1,0])\n",
    "print(\"predictions = \" + str(predict(w,b,X)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "======================测试model========================\n",
      "迭代次数：0， 误差值： 0.693147 \n",
      "迭代次数：100， 误差值： 0.584508 \n",
      "迭代次数：200， 误差值： 0.466949 \n",
      "迭代次数：300， 误差值： 0.376007 \n",
      "迭代次数：400， 误差值： 0.331463 \n",
      "迭代次数：500， 误差值： 0.303273 \n",
      "迭代次数：600， 误差值： 0.279880 \n",
      "迭代次数：700， 误差值： 0.260042 \n",
      "迭代次数：800， 误差值： 0.242941 \n",
      "迭代次数：900， 误差值： 0.228004 \n",
      "迭代次数：1000， 误差值： 0.214820 \n",
      "迭代次数：1100， 误差值： 0.203078 \n",
      "迭代次数：1200， 误差值： 0.192544 \n",
      "迭代次数：1300， 误差值： 0.183033 \n",
      "迭代次数：1400， 误差值： 0.174399 \n",
      "迭代次数：1500， 误差值： 0.166521 \n",
      "迭代次数：1600， 误差值： 0.159305 \n",
      "迭代次数：1700， 误差值： 0.152667 \n",
      "迭代次数：1800， 误差值： 0.146542 \n",
      "迭代次数：1900， 误差值： 0.140872 \n",
      "训练集准确性：  99.04306220095694 %\n",
      "测试集准确性：  70.0 %\n"
     ]
    }
   ],
   "source": [
    "def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):\n",
    "    \"\"\"\n",
    "    通过调用之前实现的函数来构建逻辑回归模型\n",
    "    \n",
    "    参数：\n",
    "        X_train  - numpy的数组,维度为（num_px * num_px * 3，m_train）的训练集\n",
    "        Y_train  - numpy的数组,维度为（1，m_train）（矢量）的训练标签集\n",
    "        X_test   - numpy的数组,维度为（num_px * num_px * 3，m_test）的测试集\n",
    "        Y_test   - numpy的数组,维度为（1，m_test）的（向量）的测试标签集\n",
    "        num_iterations  - 表示用于优化参数的迭代次数的超参数\n",
    "        learning_rate  - 表示optimize（）更新规则中使用的学习速率的超参数\n",
    "        print_cost  - 设置为true以每100次迭代打印成本\n",
    "\n",
    "    返回：\n",
    "        d - 包含有关模型信息的字典\n",
    "        \n",
    "    \"\"\"\n",
    "    w, b = initialize_with_zeros(X_train.shape[0])\n",
    "    \n",
    "    parameters, grads, costs = optimize(w, b, X_train,Y_train, num_iterations, learning_rate, print_cost)\n",
    "    \n",
    "    #从字典参数中检索参数w和b\n",
    "    w,b = parameters[\"w\"], parameters[\"b\"]\n",
    "    \n",
    "    #预测测试/训练集的例子\n",
    "    Y_prediction_test = predict(w,b,X_test)\n",
    "    Y_prediction_train = predict(w,b,X_train)\n",
    "    \n",
    "    #打印训练后的准确性\n",
    "    print(\"训练集准确性： \", format(100 - np.mean(np.abs(Y_prediction_train - Y_train))*100),\"%\")\n",
    "    print(\"测试集准确性： \", format(100 - np.mean(np.abs(Y_prediction_test - Y_test))*100),\"%\")\n",
    "    \n",
    "    d = {\n",
    "        \"costs\": costs,\n",
    "        \"Y_prediction_test\": Y_prediction_test,\n",
    "        \"Y_prediction_train\": Y_prediction_train,\n",
    "        \"w\": w,\n",
    "        \"b\": b,\n",
    "        \"learning_rate\": learning_rate,\n",
    "        \"num_iterations\": num_iterations\n",
    "    }\n",
    "    return d\n",
    "\n",
    "print(\"======================测试model========================\")\n",
    "#加载真是数据，进行模型测试\n",
    "d = model(train_set_x,train_set_y,test_set_x,test_set_y,num_iterations=2000,learning_rate=0.005,print_cost=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#绘制图\n",
    "costs = np.squeeze(d['costs'])\n",
    "plt.plot(costs)\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations (per hundreds)')\n",
    "plt.title(\"Learning rate = \" + str(d[\"learning_rate\"]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "learning_rate is 0.01\n",
      "训练集准确性：  99.52153110047847 %\n",
      "测试集准确性：  68.0 %\n",
      "\n",
      "----------------------------\n",
      "\n",
      "learning_rate is 0.001\n",
      "训练集准确性：  88.99521531100478 %\n",
      "测试集准确性：  64.0 %\n",
      "\n",
      "----------------------------\n",
      "\n",
      "learning_rate is 0.0001\n",
      "训练集准确性：  68.42105263157895 %\n",
      "测试集准确性：  36.0 %\n",
      "\n",
      "----------------------------\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = [0.01, 0.001, 0.0001]\n",
    "models = {}\n",
    "print(type(models))\n",
    "for i in learning_rates:\n",
    "    print(\"learning_rate is \" + str(i))\n",
    "    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)\n",
    "    print('\\n'+\"----------------------------\"+'\\n')\n",
    "\n",
    "for i in learning_rates:\n",
    "    plt.plot(np.squeeze(models[str(i)][\"costs\"]),label = str(models[str(i)][\"learning_rate\"]))\n",
    "    \n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations')\n",
    "\n",
    "legend = plt.legend(loc='upper center',shadow=True)\n",
    "frame = legend.get_frame()\n",
    "frame.set_facecolor('0.90')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n",
      "(600, 800, 3)\n",
      "(12288, 1)\n",
      "y = 1.0, your algorithm predicts a \"cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVMAAAD8CAYAAADKdkf7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsvXeUXNd15vu7oXLsquqcIxrdyBkEQRIEGMAcJFKkKNGyZEu21xt75s2zn9MMvZ7tsaxg+8myPBpLVhZFBVLMCQRIIhGxAXSjG51jdXV15Vx10/sDBNCAkGiSNkcP31p7repbp84+59x7vrv32fucFgzD4Bqu4Rqu4RreH8T/6AZcwzVcwzX8OuAamV7DNVzDNXwAuEam13AN13ANHwCukek1XMM1XMMHgGtkeg3XcA3X8AHgGplewzVcwzV8APhQyFQQhNsFQTglCMKwIAj/94eh4xqu4Rqu4aME4YPOMxUEQQIGgVuAaeAg8IhhGCc/UEXXcA3XcA0fIXwYluk6YNgwjFHDMErAk8C9H4Kea7iGa7iGjwzkD6HOWmBqwd/TwPrL/cDvcxiNDV5ESQID4uEYqqJTxI7DakYpZtE1BVEUUBQFj8uG2SJhtsqUCnkEAbLZAnaHCQMVk2xFKQmUSiqqpiNLApKgI5usFIs6hZJITjGjmz3ouoLfXkLWMhRKKoquomtWJFkkm09S5nGSSeexWKxgaIiCQXlVFbMzsyDJCAC6hiyBx+NB1TRS2TToBh6nG9ApFvM43A4Mo4gs2dB1kXA4itvtRNcUVLWELNvIFopYrHZARlEESqqBzysRCYeoqCgjGkvj9XYTS4Xw+t3EEnlUzYTH42I+nsZixKiv8zE9r2AYVkyKilUM43CI2GwyCBKZvEg+L6Bip6hLqIaMVSrhMOdxO4pkEgUQDcwmGyBhGBoWuw9DUzH0IoaRxWwWEASZQj6L1ekhmwdEL7mCTi6vYjNlCfjtGJpKJllAEgR0vYhkMmExmykpAtmCjmyxki1m0VUzTjmDiI4uOsgYDgqqcO4BMRZ8XvCRSzlVF5QxLlJQOFNIuHgZ4bxKrgIC/P9uN+EVurtwTBeOp2EYIFx+jM+/H+dKvqcxvlT1BhfVn4mORAzDKL96BefjwyDTi3XhV0ZAEITfBn4boKGujF9+407qOxZx7K39LOlax49/+DNCWjU2SeVzn3wAi93Mnt1v88vnnscu6bR12HjgY1uw+2pQ52HHm2+x7bbFZHNTWHDzsx+8SVN9E/OxEbq72pmdDWGxNZMteTHZO1l5UzMpx2Z27Xwbb/I1xMgBclmVkigyN+8no2p0rfBRU+njrZ17qWmsZWzgFG6nl4ceeoyDPYO8efgwTouA3ymTikzz6KN3MzgySu9IEDU1xx/9H48z0NuLIbl49a0e7v30Jlw2K9G5EIJiEJoIE5mL4fW7mZ4usGhFF28dfgOPr5LtdzyGajpCcnwKPdOOy9HIz587zG33/zd+9PQPWLp+I8cGRArFckzWIhFbkc+u08kO7yfue4hndo6yuNrNiqYcN2+yUeaKMjs5xksvBylpTYwbLUyVJIqUUS2mKNeP88itXiYOP8/ipUt5a98gtU0N2P0JwuMRlrStYWp4mE23dIA2yvDYOIfHlzM4XMZI2I/od7P2upvZ+XoQa6qfcncQBwn+6xceJZM9gCYMYJZ9uKwC0ZCJZ16ZZuUNtxJRcux/a5QNSy0oVLDreIm+fCsmX91ZEtU0AQwREBFE7dxDdYmJJQjnHkFd18/7+2JlDcPAMAxEUUTX9V+p42ogCAK6rr9nQl1YfqFOQRDQNO2q27KwzBXbYFzCIRX0i1++RPkz42YYxkXbeKV2XOp3v6L/Ksb2zP1bWEYUL+94X6h/93cemLhiYy6DD8PNnwbqF/xdBwQvLGQYxjcNw1hjGMYas1HAg4l/+NO/YGpkkqNHDvHY45/k9z6znd/5zH0MnTxMJDTN2vXr+MM/+WNMtgCbt24nmlRR0iKys52m9g0k0hbcFUtIJiWa6haRiWdprPVSKpXwBpoJJTQqazsAmOjZxZvf/woEj1FdZqahwUtrgw0jFcVnK+A2K6zq6iIeDvL5z32c+XAfhVyKYr7AF7/4ZYLBIOlMnFw+RUNDHes3rOafvvEtzBYRLQsdLc2c7N3H1MQIlYF6khEbJa2TnbtOMjw0SSYWJTQxyw1rb6HSX09353JGBk/SvdiH1TpNZUWQ6PQL6Nl5BnpG+NbXf4BsKFQETtDVrtBRZ2ZNhwevOM6Ny7wUQoMsaXFw560NGNEd/MFnbsDpd/GdZw5R1nYTWJp4+eX9CCrMT42xeZ2L7ZtNtFcOU+0I0lnnZbR3nHVr2xkcGEIWfPziF7uIp6G2yc4rO16ksW05r73YQzxfjmJvpK79OubilXjK1qIZWdKJo9S6Y3Sv6MRk8mCzBhgaGaC62U/9Datwe6pR1Qz1XXbuu6uRyMwrmEpHefj2ReTRSVkbmDcqcPgbP9AHUhAEJElCEISzcqlyl/v+vei7WD0fRN0fVSzs88VkIc7ci/dSH5x7MV5MJEm6qnYsfBY+8DH4EAJQMqcDUFuBGU4HoB41DKPvUr9Z1REw/vAOC4LJgr+qnsPHjmFzOQlU2YjMJhA0Gzfdsp1UocCmLVtA8JJNj/Haq8+TiuX5xMc+z/GBPgIBhXRmmmP7juO315BOzmK2hVm8aiuv7B5n8dKbGD01RG3AjTA3x52P/CE/+96P2Hz/MnT9GOlgDxNDWdIKKLgJh8OYLVkaG00sXb8MsVjNN7/xLB5fNTVtrXhrK9nx8rNQSLN5w1JSqSRlgQD7986wflUNkZmDrFu7jYkZgcaOB9jdP8O6xTbIjxOf6iM4EWXZsutJaSOUCh6m5nu599EOXE1W/unLT/G5TzzIrhfHaKlbx3PPP4/Jkee3/q91DI+ozIXNpDNWfN4AwfE5dvSU89d/3kKgejeFVAMH+2p5YYcXVTDwW07yx79/J8XIIE//5A0QKvnE5ztI5uc4uP8UU8fmuH5ZN+1tfnDMMTKs4g/cgbd1DT/67tdYc0OBF37aR6nop6quleu3b+Hr3/0Rn7jjRl56OUH3su0k0y/TXl9icZWTb+3YTbOzmo/fdiu6GiKpZnhx527CAzY+8+kafIE5UEvEEgmODR6n1nYr7q5t/O5fH0R1rydrb0RUUmctU8OQMHQBwxCuyjK94Hm86mf3Ulbi1Vx/Lzhj/V4OZ6xSuLiFpev6JS2vS7X3XIEPxjK9Eq6mnwtxpT5fDmf6fDWW6aXatfd7HztsGMaa96R4AT5wMgUQBOEO4O8BCfi2YRh/dbnyXY1O4/kv3c7BQydoa+/m4JF32Lr1Rtx1Jr79Tz+kytOCbLJhdTtJZJNsuf0+ylxVfOMf/yd+n53uJXUYhoWCGiSRCJKM6eiKBVHIIDqsJErlFK0ddLZ3kpg5QYVplhqPkzb3Co4NpRmQHGy6sQO/Poeihvnmt79KQ8NyxKJAMT/MXfc0Y3P4CI05+N53d1Lb3M5MYhrRWUY6Nkt9uRebXOK66zYQS6YYnkwQcEnkYjNEEwVWbbyTlFrOiYEYLV4Jh5GkzmeQJ49st2JIaRJRF4uXNtI/9WPuuGclqWyQ3bvKOdUbYt3y9bzy4tP89ufuJRh/A0Upp6DIuLwaTTU1TJ3UScs3sa//WbbesZjwSI7h/jwPPvpnfP/bP8RjHmLDyjJ0JUxL2wYmQyXcriFO9PbQWLUCv7WGt19/hnvuXU/GF8Drc9DXm0XVfBw8dIx0che1lWsJzxv0jceo6rwJybaSSLCHRSs70DUX4d5x7rnRy9KG50jbV9D39jH8dgujMyNM5xZxuNfN9lu3c9N1QUqxZ2msqMIQrOzasw8rDmayZZyMb+T4XDlBWwMeUf1QyfTMhFo44S5FQgvLLJyIHyaZLqz7jNUF5wjncmR6RcL/iJLp++Gii93P94rd33ngfZHph5JnahjGi4ZhdBiG0XolIgVQNIWhiQlks5VQKEylL8Ch/ftwez00NDSxavkKqv3lOGQZp2iwc8cvGRuY5uH7foMlncvAmKehxkMxE+HUwBAzs9MIFhP28jImwwYmXzvTCROHekeJp1PEIiMcHvklntYClQ12okUPv3glSu9gBZqjhtsefoR0SWPj9Vuprq2joa2eV1/awVs79+K0eamsqKGyphK3q4zFnUsBmflwguamNmLRJDk1QzJboKaxm5r6bvYcOEw0G8RkmmNpdz3VFV76B3pRxRjBdA+pQpaCorNj1z6u23QLhmDFXVZBKJ+iY/VicmKOSCrGD773M3zOVcxOGLQ1LmN0uAeHWaGjvpOayjk2b/0k3/5RAF17HJd5Bfvf/Ab5mcNYi0GO7n4Ri1TkYM9udux6gUihBtm+jldfj/D3X38N2bsUc3k7hnkxMSXLoaGnyRiHsfkmsatxblxTy4pFVq5fU0FnYznpcA4pcC/PvnOClw4fJ29s4Hivh6n5MMd3jiKlzLRVN7J8WRc1NSvZsu0/c3BokCdfeInZuMax3hz//PX9JGY7yRcL1PndpIOjOCUFq930YTyWFz6jVz15VVU9K/9eWOiWvlf9mqadlf+d8H6WWUwmEyaT6arquJqliH8LPhI7oCxWGzfdsIrGOjM1NTobtywhQ4YXf7ybcKqZrOQlY/QRaM5gbbJSX5+nyF6+951v8MZLR3GY69j32jtEwnE6uhqoa2+hvmkFt930m/z+n3+TgUEbSqYJvShSKmaxOFzUaA3sPThJqayVuXkfpzJL+eoJF1/5bgGzZTXjJ3tIzr3K/Y/fDVolHq+LyfkIjnIdRYtjF+wYxTFcVie1dcuYz6pYy71oJhsBn8D2u+/ludf2IDtUvM4iWmiaSiNFf+9BvHVuHvjsdsKTM9SUmgmPeZlP1zGY9OBpXs14KM1o/wgzx600+D/B0RMhFq9bRDiV5s2RUQ5N2finH8bwVvwXRmf8pIwocnaKpf4Id9+1jH/cOUJPcTVjow3cv3UNFjmJyQxmzUuyf5LlXoH4wR2gVfHMqz2EQqOkknPoQhleh4m9L7yOHkwT7OmlxS9js9eRioyxpEHFWhxm5/6X6VMmGRjL0ObrpELJkEnsp7IqR34uQyQI67f9JgcHQoRG3uHmlSbioVdYv9zNx7bdyvXX34rZbsPwBhgtOglOauw9mCKtOVFFAbFkgGHidHxUfjf6q5+1SkVR/JWHX5UUihLkZJGCZEIXTIiCGdDRSaMLMYpKDEQDUbSjWQ38YgmzngQ5iygW0HUZTTMhW5wogoFizlK0ziGK4lkRBOGi+t8LFtaHISIggSGiqQa6BhjieWXO04+EgIQkmtA1zsqZekRBPm15visLyxi6cPr3lyKQBb9bKAbSRQXj8iIKpnNyif6cNxYLoGvCv0kW6hcEDVAxDAVB0M7KJdv8PvFhRPPfM0oFePLHuxFlBbNL4ng4gauxmehcBM3qoHNJgOtu3AKJGXDXgEskl0mxauMqdrxylGd2PsnSmnUYaZ3FFYvZfTDOqZKPt0NR4uM/oKFjC9NJhbJ6N0LOQslS5JVDe/EXdAKpFBmtjGxqnkCVlbnZSn76+gCP/O5f8dbT3+bFV/6GxYvKeOQzv4vVfpSnfvYqGQXmojOsW7cSs2wincxx801bEQ0JXYWhQ/PUWMYxKTLx+DS1jU7Gx/vRuIXMvIvQUZGPd69m6+/XoxazyON1HDyRwSbZmJ0wMXPSIDYeo7tzFWYpwTt7D3PX3ZsRLXluW38PWi7HqaCDp3aF+bPPb0YPHaH/xH6WOhoZOxlCEn0oFPnCHz7M6I6vUdnYzLo1q/j+t35Cc4sPZ4VK2raCZ/fNUX/jbxAa2EfYsox82XVYi4cYHo3gtdeQSRmEp9Jsvr4Gj02gprIBJRtiVe16PKk6fC0i+fx+/uKLN3DsSJrkxADRqJ+27jr+9u++xJ/8wePMnEwRHevHXtLJzeTQKmrZ8dZOfJVl/KffuoUDJ4eY6YHjUzYyniUkjAoklUumtZyxKC90IT05G4okoIkGCHlkMYsklMhKFRhqGZIioyczVDfUk07GsZrNKIKdjGQhX8pTIYZZUR9gPBgjmSogm9wY2JCxnafrDJm+Vxf2anCGpE+T3JWt5ku5tBe7fubahWP3UQ2IvR93/Vwd8nvyQN4vPhJkaqBjczux2Kzc+dCnmY4ZfOfJ56lufICZsTRff7KXP/3dGorWOPFMFHvSxpu7n+euO+9h+20N9B8zsPsDaNkwLd4GThRgolDNSdVOZSlHSXVSv6ieA70vU+Wp49jJEIvX/wFTsxOE5gTKKutxyQbToX6ksnWcDKcp7kiyov0TWINvgRzkm995karyDrqWrqOpuZLRKYWhvmPcfGMH6fkkwbE5hNL1lLt8PD2eRnTOoTlXM5m2ENSsYL0BS/Uc0ZlmZO+NfP6vBjGZbEi4EKUkhlFJpc/Gt37wAvXWeapkK+HoCE/95O+oDlQjaFXcdOtqnv3+t1HLt1KQTNhqF/Ha2z34oy/S1taMqBbpPfAOS5Z8liUravn6t/47j2328+qeQ+w/coR1a27CkIMkxFnqmisom7Age1upc9lJpWc5fvQ4udBrOHxLiSa9uKwe6lvLONb/I+64/eMcGYqQKEqsXemiPj5LoHKOeCTJaz9+irGQh3JPGQFnGes3NxOo87Br77NsanWhGlGWtSYo81Wgxca4YfkqTAGBudEdtFWbqLUt46lxmDc1oeHHWkygSRd3Uc9EdC9Ma1FNWTQcaFgwDCuCbkEQSqCVcIgaTnMCxTbMypYShw+8hlW6npRoIZ2rwOn0Ycr2ccsiK8+G+zHZq5hTBUTDhqRD8YLJeLl0oPeDM0QqiiIGV3bRryZIdgaSJGEYBpqmXTlA9RHAB9Gu05sxDeDfh1ClJ5544kNXciV89Ut/8cTG5RY0w2DXmydwuVcyPSkyEKpDcq5DMLtwlNlwN63nj7/6NEa0mVTCy8jgOMHJED57A8mCl4Ged6j0Wqj0ViBa/di9dh7c2sXA8CTj8zqCtQwVD4JRhSiAJhlYbC7sznJ6T55ENqnolloEm5t8yY2MxvKl9Wzd0sZsKEI2YaAWNCbGh7Ca8tx/3y34yyoxSTKKkmDthhX8yz9/i85Nm1BNPgZDJqTARsKFblLGVqy2xVTWfZIde+bQ7RUUTWaKohNB7qQktJJXVepqS9y4eQU2q0jJcKEqSfSSTD4HBT1NfGIfrnI7VQ0BkvEEzd4c7TUhqqtrsdtlZGcZB48N4jJneGhbK9H5nWy9dQ1LV3bQ0taB1WViZGKAk7v3U5KamJ/J0u5J01Wdpdw2TnldHYcmbMxzPdOpat45Psbd9z1CxrSMbz7Vg6e+my03tlKMv4JS3E16OkU+uoxsoRm/v4z2Bp2f/ex5ZHeR1WtbiE0PMDLRQ02bE6/JQzoWobquip/9/Eesu349mVyCd45OMphqJSl2o+kWZIroaOi6fl6gZSGBXTjZSuYiimhBF014HE5yySBafp4WV4y/+KNtxKf/lb/50/X4LD3ceYOX1595gb984mHe3nUAS0nFyxh3dU7S1NZARXMrh8diaJKAVcxjiLazuhfmpX4wE148r96LWaYL3fJLccKFxHqhG39hnuZC4r7ymuElsgYWpCpduaPndJ9py4VjeD7hXdkyvfCeAOelwJ0eQgEB8d1xPi2XGsPJnh/PPvHEE9+8cmcujo/GmqnFiaba6Gjv5NZbriMcPIHPlafOM43fkSYbzzM8bGI21Izd+RBHQu2Mpq/H0/Rx/G03kzcFSMQUKuvrCNR68AXyLKtK0pzvobkmQSk5iNtkpZA24bBW4y6rohCfxGUqohUjROeDtLa2IpttKLkwqmaAtZzpmMrRgSHcFV7Wr+/GYoZCOk+Fp5xqXxWx+Uka6/yIRg63Q2Z+eowbN62jpdpCLj5GXZUTVc2g6XmKSo7+foN3Dg8TqKrE7lFwOnXcDhldyqCJGkXByYHeNHG1jYlEHa5AA/OxWdpbanHaYGriEIFABRQiGNF+akhy77abEcwSNqdMoTRFZ7uOQxznk/ds4u/+21/Stagen19FNSbZ/84LnDjRy8xUhlI2Qy6RwmkTscgpRHWc2NweJqZm0GyNjCQrSdhWkXat4tm9UZ7flyfEGmLCKp585ijoHmrKa6ivbeTjH7+TihoTqcw8r710mPrAJrJZKOg67Wuuo71rA3PRIgP9w0SScWbCQbbf+yDxJOSyLirr2zEKBaxKGpOWQTPUsxP9at09oWTHpIvYyBMefZ3/8rluljcPs6EjAbFf8Ol7HeRn36DBrrH/udfZuErDlHiaTscoFXoQn1OARJg6n5fdb+5GsLjQBBsF5Xw9Zybw+3FDFya7L8QZYvswlhAW4oMKupxJkv+w23s1uHh/hEvIh4OPhmX6xS8/8Td//J8RKJLJTBKJjvDAgzeyfkWRQiZHdGae2EwOtdjAyHg5EXcb8VwtsWKMuJJCEUGZ07nzztUU8uO0dlYhx+dYUm4lJs9gtjRQEpYQy8ooikYhl6LDO094bhCH3UZtwzIyRYink1hNAppkI5U2qPSqNNepmIyT9B1+C1Fzse2G2/HY7LS3VtM3sAunrYyuRUuYn5/EZhMYHZ4gERxi09qNHDh0gECtg9pGN5lslOXX12H3GkzPnkAUdMRcLWKmHcO1H1Wwo2PGJMHMWIJcyomqTpJKjlBVVkVLYyMPf+pGDuzsw++14XM4KIUVCvEoTa1mFLWAKCZIF5J4fW1MnBziutYWRPtJJEuUick+OjtXUVPVjVKSsUsWcraVzKdEatxR6qpT+MtizGer2DfhJW7dimppIlHMEg4NMleowFV9A0WlmvR0CD9gtxk4rS4mYv08vfNJvvCFz3HjkjsIj3uZSg3yzsE3kQsC2YyZgfEQhWSBux97CIddxFJWQe/JSUS5ikBDE4bcweSsgCGYUGQD8T2+5y25AHbDwEUSh7qb33zQzC3rMyypc5FLvUpDZRw5K1Oad7K88T6WrMtQYR0nYGtH0j3EU7M8dvsKvvS1n5MxtzNTakDFjUM2YRjqr+QvnnGb/y0430I8188z5GQYBsIlun+1Kj/YzQmXWJt91yK8XJrWOaXnGn51ebtX+RK9wMK+Glzqvr1fy/QjQaZ//cV/eCJbvoHDExGyc3349FnMRhx/YBh3xSyNy25gV5+XUwnQywq0lzfhtNjIyQHmI1a2tKxnTYdAgy2PXyoh2ixYaqsRzCqjRQdaPEUDU9TbTtFYkWRsboRYrpJQupfWzlYGTwoUFTu6JU6Tq5VUNkI01k+1PQrxUxx+7TkMrQbFsZ5k3MnQ8ASnwqco9y+lpjKAlp9l6ZIWfLVdvPzSIVIFDzHNw2RwlluWVGBJnKTKHaFWruTomEAoW47V5CPgTqHK/ZAop9zpIhrdg1VZi9ncTcE+xbqaJCf2H2DbDcs42rODJUs6+e4Pn6em0Y9g9hBJhRgdO0hsLk51bRn7j+tMx1fQNxBj+YoOPDUG00eP4nVJLOpez+SxIo8//G2239qOx+Ellohxw7ZHONin8+q+GJJ3LWNzdlodzdSWlSNqUYziJGVCPU57Hi0ex10Y5q/+UGFVh4DhCpGMDkJBY+tND5KLx6jxJZnKDmJXg7T4HLQ21OOrWkxwVsRpcTI9fpSJkQkaKlcwNjzHyd5euhevYWgmhNW9iFhcoKSYMcRzWykXTphLiilFVdksn3m0msfvTVEtHcNu0ZkIWfm7L5c4muziKz+3c2q2mRMjLxKQjmF2atj8FtL5IB9/7D/x+b//Ga72zxJP+WgwHaQzMEa2UEO6WMBsNl82f/N8gtI5s1YnCJyVi1/71TzX03VcXK60hfZC13khyVzKtb+YlXw+MV3CzT9dcIHw7p73X4WEgoiOiI4kGGfFEPR3x0tHEIyzgmhCEIVfERMCknBaDE1HhNOf34OVfanUqImjP/rf383XJBfB0mqK8masrm62bL+B5i4zgmcJkWI74wkvuqeKvGQnp3kYm0sQySp4KpuxBFr5+c4TPPnsz0gqTlTLEgryMkqOWtKWHAd39DLV14uz1MvG2jHuagrye8sF1tYnuLG7hWIogUU2k1IVBHc54dg4PreD+2/bRLk1Qr2nhCmXQ/Cs5MREFSFZxN7VwJx+G0LlIp564x1Up5/v/vBfiUz2kcmMI6LQ1FRD56J6CqUgOlOoDLF/cJhql5n60iydyjBieC+/8dAq2utHefyh5Tx8ZwftVXGkdA/1thyxySlMhsHe3XvYdtMWysqraW4Bky3HeHA3vuoEFVUWTLKb3oFq9u/PsOett1m+2MbybpW2xjk8LTdj8l1PcEpmYGKUf/3eJ1m7uoP6lTnysVkOv3CM8KwPT9sn2ZNYT0ZYjC3gpq/vF7iM4ywyTfP/fMzC1tohPnOLn/DkIb739AuE8g7KPF3Ulbchl1KM9b3OojqRfTuf5MTOv2fTGjMl5RRHe4/w85/uJTzuwWGtJZv34q7s5vW9uxkLHsPuCqGUCjz4wH0UijlEUUCyvve4aEkqUOvpIz/8FapdJ0jmLfzVV3r4wStVTOt3MZa+A93ZTF2bg3u2L2HxddWIrjQ1dTZu3tjJ8DsvI+l1hCf7MBX38AePlPHff6uTCm03LpeLUqn0HixR8T3Ivw8uZY0ufEl9kDmXF8JAvKi813ExFoggigiieOat9B+Oj4Rl+j++/M9P1C99DEnN0uqcZeUSAUWMkMh38ZNnJxiaqydRKCeWBrPJi6YpFHM6RUlgJjTLykXd+Hwu5uZtiLalfPe5U/xy12HsHgdLl20jPDtLhUellB7GLKoUY3laG5zIhRjBsSlkUyVL1qwlkYnisgjk8zpGYZYNi0XayqHcpJG1NDAetLNmnZ0TfS9RKjQRjseYmZghl06xuKORqoo6Eqki5VUOioJMPq9i1RU8zjKymoWYsgxBCPKFTy8n1PsduhdV8dobu8nkbcTmrZwa3o/TZCGbClJVGyfetweH7fR66LFjx+nvOU40mqPM76N9UTvT0zO4rZXEQyUqm9aiovEbn7sfWRzCZp7EJA5zaqqGHTvfYtOmG4lEgqxeuZhEIsL+nlFWLd3GzOxGzyoLAAAgAElEQVQsU4U0ckUjMaGZQixKOj3Dgx+/k2I+Tmmqn8Wet2huNeN0+Xjn8DiGOcErz59CK2YRiwXefG0Xja11lAe8TJ46wcblS1EokVFKBOo6EAQf+ayKSZqlsrWe1iXXc2po/nRuoJrDF2iibzzO/r4sRdGHpcxPPp99T8+Qw2nn9+72s7ktDsUhhqcbeO1IFcGkjM3mY3J+mOb6CW5amWBdwyyq2YLDIZGcTeCyuojMTbC0s5X2uiLXLRWoLQvz1t5BTsw1Ec5bzyaEX83hKqd3GJ020wTOfT69o+v9rd9djf6Lfb4cmZ6p99JkemXSP0/nxdotgPGuBblQLr2ueRlCFc4JonBaPgC8X8v0I0GmX/ryPzzRtWwtPmGCcv0EJ468hLe6jj27C3jLH6R30o5o92GVHchFG5gVTJKVWC4HJgvzs3HiWg0FoYV4sY6Tc3ZcVR3oJQ3JEsFht2MSIZUMMjkxSW11E7X6CFI2SHuDG8GkMBNKU8qaqa5zEprM4bbkWN6msHJxM32HRpE9rWRKFkR1gJuva2Wkvw+H+zraGltoq29gdnwIq8nO1GyCaPoQK9dt4M1dR6hw+PC4/IxMxpCs1XziUw0I2vNsXhmmpdqNrMns7zOg2ErbIgteR55Kv0ZDXYbRvbtwlzvRZANBEnB7fCh5D/G4wrJl13Pk0BCrl2xi31sHmMvO8ju/+wDF4gmi8/uorZGQpBw5GmlqbOfQocPccstqSqUsv3jqFcYmmhBEGzff30jbBjeSy82pUyCaPaiGRt/IJCVFp6vay4q2E7y651V++coxqptuY/XaZYjFNgyHn0wiyuOP3obN5eL7P/wpD97zMD0HBxmLyXStvx9rZSu5Qpx4up+V6zrZfTLIK/sz5Ap1SIKbTCLJrh0vsOqGuwhmKxgJpskgIlzllssza3Z6LsX1dTGE8D7MusJk/laOzqwjOu/hsduXkjm1nz/5nU7cpT7Kii7+4V920t5Yi8dqQTCyBIP72dARpTEwTpVzgvmpef71xQJ93I7N/N52TAmCfDZyfGmyOCMXj9pfuu7LH+JxoYV5sayDhdH0hf26tHV6eTJdmOGg6zriRRZ8L0WcwkVfMGfXQH51XAQB3TDQDeP8JYYr3Joz/bmw7wv7+WtBpl/76t8+cdtGH5Xmk7iVE1SV13FyRKeQijITKSMrOlmxro7k3CAOimQ1A5MhIlgt5JUSNtmJ3x8jPHsIq32eQGUWByMs9aVwWw7Q5PfjlctIRiII6EyMDbOosQF/Qzm1a1t47u3XcNXezGy0iWSqB7vcyurlzXQvlijlS+zfPUHCuoW0YEco2hjtC9LQJpJNOHGbsrhtGbZsbuelV5/hvofuJ5eZYWAkRL5QwGmd576PLeWWh7pZ0uqlf2yC4ZF5Wqoqqa5IoxbeZC42C/ESa7tKxIbf5rq2evY89y0EXcFZ4SKUjmD1uFnatYKJsVGWLl3LwMAMumpmcOAAN9/cgckGpXyQFWva0PIlBKOMfLYKlz9N5+JVdHV3Iwlxjh/tp+94FE9VAEFewcu7B/D47SyqayZ4fJB5oRxEH4a9BcwBEvPjNFU0c2RUR7duQJdq6Rv4EeuWtlHwXodaSFJVLlIULAxNphkaSJAVJyk4l/CLN2boHwellMZQorz19jymqs0MzPlJZjR8PgO7bZblHW3sODjISMSBZq4kVlKwSu9tS6lLGGPbCgducwLdbOFoqIqjoxIJs4vVDbt4aJMJh2sPkj3Dm7slfuOTj+JwSpw4cAJRteP3VWFt8WKym9AVhen+FDGlkaGSgEnyv6e2CMhcOop8eTL9MHBhvVdlXZ+Hq7NMzwTmLhYluySZXuols6ApCwlQ03VkWcZkMp29fprALz92Cy3wS/X514JMv/Q3X3ri07fVkp17GdmSZXjGQShSS32FQcG+nMGUn1BKIZ6KIJsK5Aqj1PkrKCo+skkVtzRHZ+Awf/SIB23wKzhTuymmp/BXiUR65yjmNSRLgK5lt1Hb0kpc6+G1nhMsXbOawd5J7rjjC7y06zh5I4VhclPEzlDfL9my1kO2KHJoVMAhpIgUZE7Zqgk5mykmyjHPPI2a6cXrTCLLKUqKwpIl6zg1r3H7tluZnejjkU/dR0bJIMol+qeP0bd7BBImbCYXh470cNMNt1OZj7C0bZIde3pwVt2EJFnpKPeTLs7itJqor/AwNzlCJhXk8U9u4cTxI2SSGYLBEAG/xNJl5dS3dXFo/wH8pgAWuZwdbxyle/WN+H0VGNYcxfQU8ZPDqPkCOUuGtrIMNdUdJKbH8CLQs3+W+VQLwYIDRbQh2u2MR2PE3LXMpXQGottQTOtwCIdodkv09pQRH/8hnroG/tdraXommkkpNZRVWljS2EjR2cZcvpWS/UGGYgWsrRbEYjfH0p2YAi1YOUQm8zZNXRJTB+fwNd9PjFYKkgVVLmBgxTBkDExIwumDuXWjiKx5MKlmNMNFJBmhXJ5kceGnPHaPjpz5DoIyw+DIcl7t7aAvaWV5nYO19cdYsfRtSnIar7+DhpYGotNHGT95gnKfiyefeoYtj9yMmlfJpvOYRJnaigAToQLRUiWZXIo0EobVg0XLIhkKBckOmo5hgAYYkogiCmiigGwsXNk7J2eDK+cFqM63Ij9oXIwgL6XzYgG206lalz+3dCHOHPx8MW686Ovlkl9cvL2nt+CeJlDh3e9EQUCSJQRRfNdiBVESTx8wfWaF5V1dgiicd10QzzXu1yIAJcpmeoeiKGIVJms1/kAAux1MkkA2k8bjcKAoCrJkRVEElrWuJTkfQc2FcNtyOM157rjzVn7+9JMEKn00ttQjSAb5Qgp3uZ93juwnmpknrem4KtvYcvfv8Lt/9FVm53MsWbOWp376Y5RCEUkw0VDfTCadw2Wz47LZ2fHSS0yOjRMLT6Ckk+QiOYysgFJQqK+rYvv22wiH5qitrsFsNvPnf/7njI708cLzT/PmjmEG+wd4c+db/PiHT+Eyu3n04/exYW0XNTUBctksr76yg3gmgrPMwYbNGxmdGEbR80QSs1RUBLhpy/VMTI7R0FiDxWJifDSCxx1A0UpUVZeRLxSYm01SXd6M1eRk397dBMrcfPpzn+W5Xz7P8UMHGB8cJDQ9RWgmxNx8jEg0hdVdgSEWWdzhQCsNUVcjIEpxKsqyuM1JSM3gM4qUqQqFzBxeNyjqPLJZRSOPbNNYtmYrY9M5ApUdFFQ72aKF0fEio7MBbP5GypvLOdq/i0SiwNyUhUhJAosNiSKt5VZaPQYBPYavDuZTkyQzCXKFEpLgBN5dFwM0NDTxzBpZDqQciAXKvGY2blzOHdtvpKO5lramRrxOB6nEDI1VFrqbHISmXqO5zgaaCa+7CUN1MTUexeawsXTZMgSg3C9BtoCh6kxOzDA6Okk6naa9tR5DSeA0mXHbHeiKzplDqgFEzneJhQ+eCz8S+DADUx8UFh7ucqVDXj6s/nwkLNP/8eWvPVHRthWzrQ5VtVAs5XG4DWQ9T6xQi7mim3iuSD6n4nPVEJnJQClB0+JampoDkJpiePgNblpXy+jgAWbm5gnUd+ByW6ir76JkUnin9yR7j2fonTAxEq2nxr+IuflphoaPk8qX8JSvIRw2E0zkueG67cSG3qLGGmLw2BAWuZ7HH+5idiqGYVTRWFHHogqNCtMws9OnQM9SUeFFNjmQrU4++2e/x/LuNubG32FqYoyG+maCoTi1zgomR4/gsKUZHDiIWRZIJmL4KgOoghlHxXpGplWMUorg0B4qKm00tZajqGnsDjOyJPOLHx8mOBchlU9Q0+ClkMlTylnoPTaKx2UGokxO9zM3NcGK7hVYSxGCwQnGBoZIz2Uxuaqw+GvpWPsAv3z2GW6/3ozbOkp7dxdldWvoG+nloTu3EB3qxZ6P4FcyQAizxYlgZFm12EwkNEigtptYJMbIeBLMleSzBVZ0LcFjDtCfWsLqO+/hf/7sJ2zdfhtKyiAdFFEdMmnVjJwZY3tbmke3NpGe2EepupUjEzopoQlF8KGqLnQ5hyEI6KKAqhvoImASEMQUAgqGAMXiPImp/fjVHhrLkljVedwWC9FIFtEi0lAr8+jdZqS5t4lPT6NTxxuvH8WCCW/ARCY2T3Q2SJnbjVlTMVvKcLoCyKIZn9uFp7wOS6CatoYNDAzPUtDtmI3T1qUicXqpiQVk+u7clI2rn6T/0QR1tTmfH3UyXejyn8Hljii8WH9+Ldz8v/zSPz6x+IbfI5lxIMseCmqB+eQ8+YJETlpEtOgmpxpIuoQsuslYVASLQKRkZXyuiJqz0uSJ01Ip4TSVGJkI4yxrQSwpZEteZufnKOp2wsk64sUmGpY8xNM/+ReCoWO0tPnI5dJEYnYKeQclm5Px/nG2rQogZnpZtmQ9LYu2EZ7+AZ0tbuLhFPV+C37TcTzSHKHpIQJlDsxmE5mcwtx8kv1vPI/fZmP3m0dYtmI5/vJGmtvWEJ6ZpGSMs2FTJ7JJZHFXE4oRJBSy03sywtCUn0WL7iA0NkIxNsia9a0USlHyxRjZbIaqqgYKqWqqGyqpawoQio1RXVVLeDaLv1LAV2HG4lBwuSRaW2toXFSHS1WYj0eJR+Lcd/cnGBiZZSZT5OmdBjV1K3GZE2SSM+x5Z4aduyMoZVs41T9OJh3l5m3refRTW+luvA6Xp45QKMT8+EmMgkIworCxs4hd1NmwupnOpgzhkR1kZ4MMWV0cOpGkVGgkFsqwsruS//p/PsRUz27WrFzObRs6mRvejSoaRHUbx6bXMp1tJ6ZWY8hO7HaZfCGKzWZDLSoYooABqKgImBB1O+gOHBYDhzbDfeudmJVjqHmDQhFUPYuhz1Nhz2AuhPAoSTLJIg0dnQR8Mm31GuNTEdKRKIKiUFVRQXlTE+GJOV5+7W1m5+J0tTeTToTJaRnGeqOkCgaKGEAwDAw0NEnAYshnlz3FdwMhgiC86/4bvyIXW7e7MPJ+JdK61FbMfysW6lxY9/m5qOfKyLKMrutnLb+L9fPDOrvgavohSdLZVK+rGaszW5bh1yRp/2+/8vUnajvuRDS5yOsWDGsAk6eFkrmGlNBGSndQ0vKIuo6kieRsJUTNSTLrQBLtuOUMlsRb9B/6CRZpFotDJh5NsajeQ7oEw6eO4Hd5EXQndQ2V9E/tZ/UiM401Oqu7Gzh29AS7Dwxw07Zb8TU20d7QiKnQR0VZhmPDM0xlfAjFIFruOItaG9j3+i+5ZYOTlV31rN64Gr/TzuEjPeQVA5vHSzolEQolSKRiqIKL8tounn7xAO0rtuGu8pPK2fA51zA5M4YujjM6lKPM3UAq3YCquti8qons7F6ypTQVVU4KxTRl3goa65fyzoFe8kqKipoKHC4boVCQutoK7D6VW25/gOa2mykpZUxPhLDpOUqKwUwqQU1dA4MnhpmJpghmMmTFdYzFapmM2fCXN9O15C6OHY6Rt68iXzIQHXYmYxGeeWsHw/vDTEejGEYem5rEqpVoaKglFnyVTLrAnXeuQmcft97Sjs8ewFxtMDWQwYELh7nA2OgeorE5juw7zGQwxmhfD7Kew1vbxv7hFMcnV5MSmlCtfnQ0RCGJU9SRBQm1qCCKJhDEdy0/C4IhIxoSsjFHU3mEG9tDWM0R9rwTZPGKm/FU2jELCdToLKWSQGp+gnBsnng2TVONFy0ySXXdEkaO9zE8OEB5ZTkjo6NIxQLuQA0eXyXzoQlCEyfRtTQV3gpGQzEUWwOF/Om1Tt0kIZXeJUbdOJ3zCIjvEuvFIu1n8H7dzA/LTb20lSpc9PqVMgv+oy3Zq82OgNNW7K/FmqmuqjRUl1NUFbD6SCjVzGcbiRm15KQKdNmOzWYhk42Ty8axl0zYizZ8ggWPkMJl7iHgzXLfvatZviLAqtXlPPapzaxY6kYyTbKow0F9ucrU0PPcf5efSt9e1q4tY+3yRn7w3W8haCqSmGd8+jB9J/fQ27uXymo39jIH8/kse/v6CUdrsdtdqJk5Pv+pj5EMTnDy5BFSoWn8jQ3cfut2UqkUR48eY2QkDYIfXfRisgc4fHyEW+96iJd2x3n+jSiDYwF2vamQz1bhcFbS3VWOWc6SzwaZm+lHNMIUciM88shjZLN58rkioyMTfPXL3yAcHaa6poJEKkW+oGGIGhZHgXA8yQuvHuVr/+/b9B23Mh8KMDKc4vW9+2ls6+RHP32DmdkgtfVV1NdWYHfkiGle+tOtvHgwxzOv9LByxQoC5jBuOQ+qSDptxpDaUASBSCqELmdYu64Lp1UjNH2QQPMKtt39OGlFYvHaLrJSkbLGFu7euJx17SbE3B4+dl89129Yz2i/QKFyDSlLHVjKWLdqHUZOwSPbUawGqlVHsgkUlAKqqmIUi9glGYpFTIaAbJw+yVOT8iDkQUqRL46z+YZGRHmE8toq/LWdzOesxAsa7R0tWCUDVYxhdatsvnUT85EMX/zvP8FSrOHUoaNUB/zIskxB1fBWBKiu8Jx24TUVk8lC9+I26gM2GitLbFrfxGD/ETRNQdEMSiUVWRSRhDPnjJ5bM70SsbwfsvmPJqqFJ9p/lIkUzlmdlzs74INs70fCMv3yl//pCZOnHZU0hkVEsldjmOuQCjY0JAzZQFdUAmVebCYdlHIEScYQJ2hwHedPb5tkkbiLhvZqrA3tZF12BG0KpzFFTFxKrpgjEZ9n9Zpm9uz+Jp/+VDXh4FFSsztpCEB8NkXByHLLXYsYn5og5+riobuuI1DsIxwXSHhvRomdQFZTGPEebISJx0wEPDX09U0yMjBNTpEZHJ2hvraJeKHEcH8flWUCmLOoJheDwXKsfoVifhO9AwIbtwbYt+9bWDU/4eEeQkaJ8o51JMJxMvGT1NXmcLk0NCVJIVNk1ZKNWAgwm7Zgs1WjF53Iiokyp4Ghhdh6UyteRy3hqMZLO57huhtWYnd4CZRb6V68iMHeo6y74U46l99N34kMx+bNYG4np1SiCWYEDGr9oIz/L1YtslJWZqKo5AhnBHzVcczxk/z+HYvplg8w0vMTyp1ehvM389xQge+/EUaIb+LlV828GqrlqedO8PCn2rn1vmZm4xpvv3CKu9as50T/i9gtGp0dq7ln281kZ97GEf8F3evW0tsvM1PyY5IEOlMpNl1fx8zsMdL5OUS5Ak3xYRYkLJqIpDswayYay7zYBS9ZvZE6b5xU1Z186+UxVnRvxJY/hsvWx/hImpUbu5mcnKG7eRlLljQxn5lFE0vYrBKlUo76hhoautpJanZsVoNcdIyKMjPZfIHyqipCRpZnd82RNN1GtOjCLefZWF5gMhfGa3IhFosIUoqC1YTmrqEgjKNZ/RQwkMU8Ft3AXnKgmn71H8KpgnE2AV2QxLNJ6LrA6eWNy4hq6OgY6KfXGc7Woy24fjERJPFsHbpwLgFe4uLEIgjnTmK6WGrRhfvi/73I9IzuhW268GSxq2nLme9/LSxTRAlPeRXlFTWkE0lkvYSgZjDMIqqkU9JUBJONQkkiklDw+PJIljiarGHxVTMcM1FcUUakfCW7Tq3g2z9YQ//Iw0zEN1PjsrJpTSOPfuo6br9tHUO9Bn55KfVOhUWLO2noWkfX+pt59ON307//ebYtMuPL7Geu52l6dv6cT25fjTKzi/+PvfeOkuu47vw/L/TrnHumpyfnhDDIkQAIgiRIiVmisi3LsqW1LNtnbf/stTdYXts/2ytnK+xKK8mUZEsyJZE0KeYEEjljZoAZTM490znHF/YPABIIAyIoi5LWZ7/n3NM9NfWq6r3u+nbVvbfurXVroKYZWLuKarmIWirS1bsFKgqiYSHgqeVd9z+ARZbYunE1hXyeUsXAZPWzEi+RzsPO9etwmSM4LeNEwwfZvX0VIxdOc/d972TfvgcZPDWL31OLWZLZs2cPExOj+ANOgiEX03NDWOxFnPYYv/5r99HTa2Hd5gA9Ax52372GUG2QEydeYHWfQltrid5OMxcGj7BhUx+VQoxf/eSHCa+cR7HGyGQHsVUK9IRc+F0a/+UPfwmT185oNMo7PvhbiP4+RufzJAoiiuLCazfT2Ghi6OLTzKfHmEiUMTVuIpIRKOCibA9xfHIJk81CbuYIVsXMPzwyxu//wSiPPSOwlFoiWXqKnbVlfuX+LZw/+Tqf+J0/5vXxMu51H2T41BRmVcRWidPgiHLP3jym2SM4YudYGyizZ1MtkjSPbl4ma06SNeVJyzCbLPD6qYs8+9IgsXSRifEEhYwbj309JrmfwQtVZMVPLJrH66nj6JHT1De2U60KlMtV4vEkPT19BDu7KWfzlCsF6hu6WV5QUYtBElGdYqFMDX6s6RyNwgI11cOsa5zmPftlehp96LKLpO4npfmREXFVM3iLAUxpB1LFDohoUhVNzl73q/92rFJ/1leMbyeu6El/Gvf5M7Ey/dO/+Oyn+nZ+kGK5jM/jJhmLQbVEXtBBEpBNJipVAVG2Y7bXUC5MYLPaKagmMkVYmo/w9HELrxztYnRsAFlaw9LSUVBOY8xPYHMkUFxZRi8ssXPTrcyc0xD0GItaBznnXr70+Dxr+tZz8rVn2NUbYtPaDkK2HOGJYQ4cOszD7303Zw49StBRQi8k2L55Oz5PiIlzYXbcfR9Bl5ua1T24bDKPPfpPzCxOIEsygWAIVXGSLplZipjp8hYo589R51ukmD6MXo4jGzA6M8PgiIhZHuDhe+/h0MvfwKmkSKUrhEINnB8eoVyu0N7ejlFNMnTuEK0tPlDS1Lc5aFnTxKkXpzE0ExvWtYG2QCq6wP4992FxKqRicYbPnUOrVsjm0pw+c5gNqzoYGRqkUEwztxRhJZ6noNZyZmyeSNlPpOiiqLnQDAvF8DT7djSwfrWZ4ycOMpnvYayyFU30EtNESrYAiixTiI7SZAwS8ppJxLPktRrKUhM+aZnd/bC1p5+hkQtEczpuXyMWhxuz20NHcw1j42k03eDj79tG/OQf8OAaEy21BdAizKzkyRsucloVyWxGEM1IosDqTjs9zSp3bnWybsDOl791Hoelg+PPvYpCgmg6Tk/fPo4cOsDM+Cx6xUw+W8DhsqPrKhaThZGRi6iFErNLSzgDOrJmxibXkonp2J0ynqCB31Rh89p+NvYGsKmv8PGHaujwTfLkk69icnWR0qxY7AbbGjNURr9No8NNOauiySaQq5fdJuXLZ9GvgXR9S/nNJgu83rVvtgW/EcQbdnn9pINXj+Hasp8Errda1jTt+4aot+q3++/Cmv/nf/m5TzWtvQ9RNNCrFew2G8lEHE+onnK5AKjI0qWcQNlcGa9dIpcsoplqqFStWGQ7ycUa7OYg1WKUpsA8bbUL7FgbpD/oxeGzMB9P8+RTo7SEtlKISExHY5jbHuKLT4RZzHaxshilIeinqcYEosjRo0eRFD8lLHSs6mPnQDNiNcm2rRsRRAV0GcVUw/GDr9HR1YZaSPKZz/416zevQ6NELl/GbHfQ2d9LfWMHPd2b0WIXKOQGWZwb5Jd+4QH0skFLcwfDYzH23fFrjI8lqfMJVLKT+Gw6zS3rEFCYmpwnGsmwqm89F4ZGKRUrmM1WliMrbNi0AQyJ5tBujIqJL3z2H9i1cw3bd+zFKDr5m898BotoI7acpKG+jenpeRTFTCE/QldbBza7k2S6iK75yKQ8ZEpJyrKPbMWKKDuQBBm77mLnpjpe+N6XaW3uZzE7wGy5E6+9TH2Ln8XIPE1BHwPNDpqFC1jUOR5+z3pEc4JsGfat286Z5w7x5KkxHvrIx7njnQ8iVQwsRoE9m/sZGn2a8ekUgbo1TI0M0Wieo7D4OGavzKrNW3nlVI6C2EtZ8GEug6hKWIQycv44m9pT3DaQIplNsXnX++jvXYNDj1PMj+JvdOHzraWjvYbp0VEaQy1ks3lWrVtNfX2I6FIEWVKQFTOBuhC1LSJWi5d0NIvT6sbtE7B6S8xNv4rTbkI0UjQG0jT6ypTj89x51zt58sVhSpqIy5ZgnW+YD9/qpKbeybnxKYqSnTIihm5B1O0gXkqI9wZL+A3Olb9VIngzsryaYK8XJFoQhB/iJytet/6NxnG9SFU39hT4t+Ha5yTL8vddoq53bPZauXoss6f/XZDpZz7Vvu6BS7/gooKqg7smQKUqoJUziGoOq2LCEKGqqVCRMApFPN4gVQNKxRKfeG8bv/KLq9i5IUqzY5Am2cbpp6OcPPFNdEs7X/uXNFVuYWY2j0mKEc95ODCsEym0YLFvoJzNY7ebGL9wju7eei6MLmP3byAazRL0qDikIu0dLaSzec4ND2G2KiBa8YecDI0P0ra2m0cf/xaCIrB+8wDve++HmZqZZuOGdmQjzfGXv0c5vUTQX6C/PcjKjMpSuIJhNjM152NoKIPLDVs3KLz6wrfYs2UXoaYmvvmNR7FanKzqX0c6naa5eR1mxUMsnqUu0MCBl45RTIo4A800dWwgH0kgG1Uunr/AzPwCyyvLGBUds2DBZXNhtVrJpzNIYhY1l6XRp7Br5zqsokg2XsDp85AqShgmF6oKslamoreRTZxFKC8z0LmbsaUaSp4auhzj3LfTgxY5QSUbJ71wlj7PCs01Cdb26tT4NI4OxzhypoDFN0DLrR/if3/3cQ4cPIzdauXE0cOcPXuCznaZ+z70YZ54fRHB2oZkCLhrNXr3PETJ0ccrZyFZaADBha1axGKyoFeTWCunuHuLGU/xRb7wlWFq6ppY0xugvTZDPHaR0ek5Tp1JYlSjSJUMZpOVQjlPtpymIRji3OmzdHf3UipXsTidIGtMj84hGTKKJOH2OlCcLmy1dSRSKkq1gFEO424OouUVrMEGutY8RCJdITr/Or/7kTa8wmkW4hGWUmZK9naK2BANBUGVEaVLkabfsA39MZHpm+GN1vkbHCe9CTK9Xrs3Wv3+8DCFbw/eqsrj6vr/Lsj003/595/qGngnhiChCzKaLJNXNcrpMssaldwAACAASURBVA0BJ7n4HKE6H/lCBlm5lIHRZ8kRT0/T1ObBbElSnBllZvQsPkUkPnOa84NPc89DaynmVRT/rQzObSaR7UQXqiiWYxiZEmazHTVbZu+2XfhscT7+0TvY2DeAz5JiYNVWVq29l4mTh2h1xBgamyIciTA8NkpndxcriTAltUrXxn6a+9sYGxsilk2Sq5RJpeMcOniSXC5BOjZMZO4sv/pz9+OtbWJ54QJC1crMuIVkwYzFYyGW6CIU7OT2/S0889SfUU4nWN+1k5eOfg2zVSNXSOIL2JhfHOPMhQUi8RUE0aDG78Jrd5GOZHhl9AVeevoldqzfRqBGQbIVSeRnWLe+lzsf2M/M6Bl0rciGTatYv6mPQnYN2ZUMXS0yxeI5xi8+j0lYpFQOoZvsFFUBWTRQqJIwfJQLx9g+4Gf+3CwF3UneucQDGyx4swexJs/idQdpCPlQkxcIddXjEFs4e0piNLGRWbuPbLNGblTFXWOmKkks5yVi2Ck4aljvq+Vvv/pVSoFNRCsugs21DI24eOxQgqePJ8iJLWiihCGHUZU8eRk0k4mH793LttVdeKwGVu1OXF43xw4+TkewTH1tA8HGdcwuVnnPgzuZuXiSarlMY0sjZ8+fxKiINDc0Ewo1EKgJcmpwiO89OUR9oBO1BNlkjmRcY/hsgunsrZw8nCXkaWJ2YYSzp87S2LOF+3/z27x4TKZKK7qRxeGKEM/OMz3oJpxfxVy+jqooIgplTBS4lJPo3w+Z3kidcL1+flI62xt5TdyMyuPfBZn+9d9+/lOb97ybyMoiJrMJTRdQZAtWWaVc1bApbtLRLDZDxm9WMBSFxWSFuoZ2lqYXsWNFtpu5be87ePHZZymkhrhl5wDf/e7rZPIr5JIq73r3RxhbmaO2xk5pLkyKDE2NXeSKNkbCJhbDo2SiRxl95TVOnH6VQK0FmSTugInDw0PcuWc9Hq9BX896nvneq2zcvIGDx14hHp0kk5jCZjfx3AvH8Net445dmxlYX0uxNEnQ38bsTAKbx8pcYpgjU/OkjQBCwU+t28267asZOnuYrpZhdq5r4MATZ2npaKdlg4UGXysuhxu3M0AiVqS9aRMTk2F279pFKFTHxYnzmB0Ksk3CJzupFnUW4jnWb99PLKERCjZz9PBJ8qkIa9b1cujMYcYWI1xciDM27cfR0I3VkmZp7GVcVgeCUs9MxoegSZjNUYSiF0O0IZtG2V9f5cLTzxOV+0k74cPbl7HGTjM0OoirrYexhTAlnJwLNzK1IvH8ZIWjKxIpvQan4kLKa8iqRDwVxvA4CIV82JKz7LJXePniIM2eO4hNLHLb9tU8dWQMX6iZZcOFpaabQrRAf2s3kaKBrpZRNQ+W0gqb6+dZ025nbFbj+dMRnj0ishCHlciT5JOTzE2CEmiFSg63TaVcTdK/bhVnRybZ2n8bpwZP4Qj4cLevppKwYJR0zLpOKbbCtls2MzM9w677HqTGv5kjh5+jUB5m164O9JyAkmmhp66F7Y4yDaYkZ5ICU+kuZibbGEo2E1cdKBYF2VAxCSqiqKIJyqUjsVdZ7W+EmyGCmxLkyyT+g1ihl6zz0g/KDeGSL6koYQgihiCiI3z//c1YqW8UieoKrpeX6tr7vBlcUZHcDDleTfZXdKk/TJ88c+of/++35lssFpLJJB6P5/unFwzDQBNkDCRUUcbpq6ViSOQrOoVsBqfdQiGbocbrIRpeIrFyApc5T2OdH1kMceR4kVDj++nu3kW6EObF175JNF5heDxBxS5jRqGqK2hmL3PRDF0dTSTmR6lWSmhVma98+V8olgIYNNPcuoep2TEy+RzZbJb1GzaQzMbYtWc3r712gonxKULBen79N36NrVs20NzQiNfphaqAoMtoFcim8kRnlrj/znsopbJ0tzczv7zE8dOjGDkXa9v7mTl1GEu1QHo2wrEXTpIu5HD5vUzMTpMvl5hfXkCUVFStyMXxQZxuhVI5i6qWGb4wii4JxNIJvvTVL3N68AxL0TDxRInFcIbnXjyGxdqEydzM6bMrSPYcZdKMTY5gNnmwmGqwiEEUZxBDdlKsiBiSBclkwWf3IlClty9EY7CMW4qiVHIo7hQ6S8SWLpCMpBifzBHONZOudrKcqaEiNGMQQFetGKqEaCogC5CNFpi6MMmqng5EMcWuVc3kM9/g1389QK3nLG1uAbNuR6lY8Fp8hAIORkYPU6jE0KomJEHGImtQiDB38Sh+a4nmRhMOa4W6gJcadz1Wq51qNcHF81N0NK9i7ardrFm9G6etmWCgh8cff4zZ2VnyuRJ//Fv/iZ5VA4huJyNLk2x/xw6mF8+xfkcf4dmLLC6+QnOTla3bbyGdh6IukijGGJ16AYunjCrksIoymYRCIlNLWfSiK14KFQXDsIPmQNScP+1p9rbiJ+U18KO2fyXR3tuJnwkyzeZyjE9MYjJbkQUBswSoZVRBpiIoVAQzqTJUzU4qspN0PEohm8IkGGRTcfweJ+vb7eQiYyzPjnPPfR8k1LaP8/Mu0pk+Qs1+0oVhFHMvkmUXa+94F/WuesIrRQqim5q2dsxSkXffvhaPr4hmFPD4mvju40c4PRzj4kyWxtZaqprKF774D+SKBeoafHg8Hn75479AOpklEUnyyBe/RCoa5oUnnuG5x58mHSkzNxnHaQ0Sj2Tpb2xn8sw4H37oYaZnT2P3eUlVanDX7uUb33mBQK0VgTIf/cWPs+eWd3Hm/BDPvfIisk2mKlZZjC2wbcdaxiZPYnNWsDlUmlv9dHa1sGX7LVQNFXeNHX/IieIQ6R/o470//2761q0llsuTrSpEMmba+2+jahJJ5LM4/bVY3V78dY1MzC8SL3ooiwEMk5eqLlGuqFSXFxk6dwiHN8utWwS2tWkMHz2O4PVz+913U+P2smbNdiRPF9b+uwgLW8C/m7KlD1XyoqtVULNUq9N89APvx2F4MetWMskVZmZOsbmpzL13qLTUDuEzzuBNncIjJml2mSksThGdOcmO7d3YbAEkUw2yIeM3F3Fr01hzF3j6639CjXOCzastLE+ew6S6SEWTKJYUHrNOOZ9HsnqIRqs89u2XSSyVUcwifl+QbKaCLFn5+ff/Kj29XTR2NJHRM6jmEoKeJTk7Qo1zit42L3PTKsl0PcMTeTJamY/88n28cux5EtlpxMIcToudNI1kRQt5yYymSGiCCMigm3/a0+xtxfVSybyd/bxVYrximHo7Uz7/TJCpbhh09a1mcXGRQqGAXinhddsRjEsDNJAwJBOaYKGoSTg8HtxeH9liEUE2YbU7ePnFEV566RQ/9+GPMLN0kgsz38bVMIpoamdhNo1QyEEuT8DVyMUJg3Qqj92kIVdX0LKTyFqcAy89RU4dJZkfx2TKsmFDHWvWWNm0yUI4skgup7N27S6OHDmH02Pn2499h8cee4JYNI0iW3n3A/czMz6IYjIRXopRU9uB1V7P1FyCVEFjenaRu+64jxeffw67o4i7to6JOZmIs4O8txVHexd5i8R3XnuJM+FZdt2yB1mWqQvVouklPF47f/f3T/DAQ/tZu66DipZAN8qEw8tElmOopTJWRUdXU5hNVc6dOkEkPojbU2DT1nYaO7xUpTyHTr1KeE4kvGRQwUZar3B87AzmkJ0ibgqaGb/fj6qVEYwMHcoi1dwchklFrWTJJvMs5ut47WQb56YHePG0lddGUuBzs5gZpmCyEC3lKOo5KmoYuzXKb//GvfR31nLm2CuYDRBNDi7ORTHXd1AqFehf9Yv8z78vMj3RRcBfpLF5Dq1whvTicX7rY3eydPEE+RUTmWSOZGSB+Pw5tq72U06MEfKacBphho4/wsd/cReKrtLW1IJsyrJ/Xy1m6xLPP/+PTM4OEo3PEPApBINB/P4AR44cwmwR+Z3fex8zRw5QI9jQkjYaPBtRYyK9Dh+xiUmsmpUzR8M4LD20N22knKkyP5LmQz/3Cayyyl/9/jsJ1cyh+tPokoompKlKMTRTDE1Oocvpn/Y0uy7emHeK7wcLudFW+EZEdiNL+RW5cmb+ShvXkuK1JHf16aUbxTe4EiOgWq1et89r24MbBz/5ceBNWxYE4cuCIEQEQRi+qswnCMILgiCMX371Xi4XBEH4O0EQJgRBGBQEYcNNDUKUyOWLBGqCiIKBLAlEw4uY9CKSXkYwKhiahqGr6LqOxR0gUxbIqwImp494oYoS3MJi1soffvrzdPe0Ul9TobuxxHzyAH63hZ4aK27pOVa1ThC7OM3R82dxm6PUGRfokKdRcytY3DV4A3UEaxuxyiLm6jzl2EE6amZYicS5eHGJquagu3sTE5OzrFqzmrbWdnZs343X4Wd2fJxQwENJ05GtLqbmokTTGprJjWp2MRZf5nOP/CMVQUe2l9AQEOQ2hmdXePDhX2HkTAK1pBBdWUQXYkQWlnCarVApY0KjodbL/v3teDwuZmbHcbvt1NXVMzkxTzlZRNF1CokV9mzdQNDjRNFVYvNLuCw2Nq1bR7mYY2V5jn2378FuSlJf5+C2O+9nNmJlKdvMfLYLHQGLIhFdnqahxoRTydDjmKDJb0YUA/zzd88Tr/YyqdzC2dkQ3z3hZM7xHjKOfUwuigRFHatUwaQVEEpp7GIVNRPl03/wn3HIZqZGT6NYSxQEiay5mRVWc2DUxZ9/Y5aY40GOzbWSNtcysH495aLGPfv2MjfyBA7xBI3uGF63iY5mH7/9yZ8jsjhJIpEg2NBNajrM7/76vUyMfIeeDjuGXsIf8HDk1UeZnDhJOLKIy+1BEhVSiTSNDc1s2bKFu99xG//x7/6Q2gad5nqZhcUEI5MmXjvl4OC5MiXFipqtsDI/h0nOkE9eoKdJxqWFee3ZRzl2+AW6mizMHP06LiFGvlLBUXVi1cwohgyIaIKEKig/8iR9O3G9FeXbvR1+q+O6kR72CjHLsvwTMW69GW6Gpv8BuOuasv8EvGQYRhfw0uW/Ae4Gui7Lx4DP38wgdMPA6XRiGAaKolAsFnE77UiGdll0ZBFkUUAWIF/SERQrdQ1t5EsaFV0Ap4+zF2eQLV5mplZ48P4PMX5qjNrWDKnUHMXkHLJ+nPELj/Dwvbey7+47mB45yofu3cb6Dg9Oi0CmWEUSa2hu6Mdt9TI/PkY1u4xNSNLR1UN9QztmxcXySpLG5hYWFxfp7e0nEolx6tQp4tEY8egyuUKeLTt2MDo+Q7ZUQTRbmVpYwF5Xy/bdexifnmBhcZaxiQnAQcDpZWpwhqC1gXZvC40eH0YxTmRxBbfdgd1sIegL0BAMYrHYeOqpp7BYLMiyzOuvH8QkW2hraMJltSPoOpPjo3S3t1DIZjBKCs888QrxcIboYgqr4ub1V48iSdNkstPk8yXyJT9u/w4yuW4EwaBYzCILFTLJJWQKeMwJ3nnXXgzBidvbz2LSRtbWiabYWSqYiAmtxNUm7NZe5JSIls1hMUQaa+uxCFbskouQr5GJ8xfZs3Mrik2nYOhUTR7yQpCU2sliRWOmlKHiqUF0dfL5zz3JQ/d9jDPHh7GZc+zc6UVVz1IsJCmVUsSii5wfOU++XMXmCtISbOV7T36Dzg4P8fg0/QNr2bxhIx987/uQRDN2m49QsBOPO0QxAzabg2effRaTIjLywuM43bCcmad19VpGFgscGskRx8uB88PkUnGKpShr1wYINaigTtPVrNDRprCqP8jOrb0E7SZmRmeRpSBK1YNJcyEZDtDtoNsxdNfNTIWfOG7GkPPTHpcsy9+X69W7og/9aY/7TcnUMIzXgMQ1xfcDj1x+/wjwwFXlXzUu4SjgEQQh9GZ9CAioFR3BkNBUEbvNQzpTYXZ+iVCTj5IWRieLKMskUypgBylNOh3GJEk4zFYsWo6H79pLi9vC9776Zb74p/8/CrB/427ctat56vAkNW43axpkNnXleM99e+lpbGdhYoaZuWnm4zJFeRu+kJ+TF+cZXpbY9M5f4/yyl9eGDMaHltl35+1YpSxqfpH43CRtjSZGzg8iihZ61vSBrFPN2ylpcc6dPMvn/+YLOG12XJ5anJ71SFoP9a0RutY7MQU/RsX2DjTLEgEliTmZ4ZUXT1J2N1GxBRE1J6s29mPzuAjHEkhWOxen5gjWBdi5Yy+r+3ZgMTXy0P0fZnJymoS0gG7NUF9jwyhIHHxlnMk5O9FqgKri5MSZ0yRSOmbHrQSafgVB6kRPjPCt//V54qlGlnMBVBdIihOblMVlDmI1ZWjUpknrMdzNHUyWXIzZVjNSdKGlJFxJnV29Vazl53BVdcjKKJYc3Q0W6sxZ/GKCoEPF7XHwvo/8Mh+6r4n8UhRX6TCexCR+VSFaHEEJlFnj3EK9kkUrvY5TU1i9dj9PHD5CuqaJx04EcTk/SmdtHdaVKe7uzTJz7FHuu/e/0tF/P8HWFVLCKA/uuxMxpZMrlcnnE7z+8uucOXOKpbkVtJLC4NA0B14/RVNPH9979VlqfO3kozmWx2dYuhBhOVdgJW1neD5ApfX9HJpzYKrWEo0rSA6DM7PPMROb4eDJi7gbb6FctGDElhg68RIde7ewYcM6gisrVGwrLMpmVlQXsgZmvYhEEUHVEVQd+XLglmvFhHgpoIt+Y5K7evt7I3nj5CqDUEU3qui69q/q3igX1I3kymrwagK7lsSuNyZN025o5YcffmrqWjXDlT6uXHO1WuJGz+RGq9ubCYZys3jrOXUvIWgYRhjAMIywIAi1l8sbgPmr6i1cLgu/WYNXjtqJkolyRcXhdGOVLcyMzyAKOj6/hUw6QY3XjqGnqBggSB6KVRNVo4hZr2V4bp7f+eV7IJ2iriPA5//iKf7iM59ly+Zb0DQXDmcIq9PBt5/6OlOLy/QG7Zy/+DJdPVuZWpijklpkeSSEHTO33b6d8bER3PY2Rs9N4vQV+Ozffh6PtY50Osnw0CCGU0W3eFmJLzEdGWcpvYBMCCnlRZYr/NGf/C5b9tzOyOQy04vLSGKI8fMK8aU6kmkB3d1EtlBlV3eATasELpw8zrve/yEQID5xkmRmBbcrwLEjZ2lvV0gkUticNs6fNxgcOsXD73kX3/zW11lY1FhTSbNh42pOHTpNX3cPxUKBrs4QM9FFElGNYsnCqvX7ODsu4va7yI1XsNVuYSJiQvZvZS5awbClsFnmcEsSrXYz6dR5uoNJIula/uk7x1EdXWzfdivPvHIakyJQzOWw2+sRdQ1BSCCb7ORyGZobLSwVXEyGSzgtfizlME9+5x8hfgqfywHLJTb7Z2iqz1Lra+Dl6SIupYxayrNxy3qiY6OcjVRRLTXY7bVoyTJPPjlJohjkEx/rZPcdGykVbyWcWGApP8g63U1LSOfIwQPc+o776dJCpDJZ1m3czXPPfAuHLYAhCKgqZLIGLoeT7s4uFpbOMLB5I3ndxGIcmuqbcHjLPHBHG98+8gL7trQhLp3E7e9kfGKBd73nvxCNJxgbn+Sv/vaf6VvlZ35xGYfXjJaKc+/OtVgxGJ6eQ1NVDGc9RraCZOjoonwpkAmXMwZcdw4Y6MaliX8pov8l3EzA4zfDpXQfVxL8vb243hiv6DOvJbOr694MoV2tF73Zvt/qWH9U/Li1sdf7pK5rPhME4WOCIJwUBOFkuZBGF0R0QbysRzSBJGO1uRFEC4rJhqiVyaeWCPrAJRaQqlW0igSCFVUEu60dXXDx91/4AlMrc8SjWcpSiJmVEmXNzZ5b76dQAnegnhwGp8+XiSdlbHYv4fkLCKVZHPoiklakkFihuUlHFyZQ1QQmgqiii0zBoKhDXUMru3btp2/tPnrW7CRTlvDWtWF1N5ErOzl0cAanq4Hm9lqOHH2SVHoWmyIRqGllcrzAwOo9GJLGSjqD6OggGZ5DI874zDFyK+P8zz//E8Izixx49TAvvXCYakUimchjs1no6+tmbn4Gs9nGKy8fxO32sntPI+9++H5mZ2epCdQzfnGOHdv3sHPnLhyOABpedLGR8+dXyKSSKEKGnrYOwhkXet1dLOsduOtXUePzkdcqpCU/sWiWUjLG+YvniFR7qeu4i6WYwvGjQ4iGjihpuBuCLESKVCsyLrdBTY1ES2sH8+FlkqpE1RkkZ3KiIlAtZZErVarMYbKvAo8bwy/x3MEVEFyMjh7BUIucHxylqBbwmA0G2gN0+w3WNxSx5l/joTtkMslBfuP3Ps3P/9dn+M+fP8urpzVeeXKFp587TU1dF4dePUa+pCFbvWRyBt39vQxs7sfuEZmaHKKn00V4fg5JMrFjVz+SNYe/uZ7BWRHRvopqJUXIvczHHl7P2dNHySoOIrksiFZOH73AsUPnuP3u+3G3NrIUqZDXVCSTmaHjp2jz5vjgHSKf+uAazPGzmCoJJDQM4VJo66sjNV1PVENHw0DD+FerwbciN5hvPxX3pesZsG5U92Y9Aa7d2l99H2/1Pn+cz+JHJdOVK9v3y6+Ry+ULQNNV9RqBpes1YBjGFwzD2GQYxiazzYsgyt8X3RBQNYO8WkG22JBkK6lMHr/fz+LSPLOzU5gQaQ7VoOhZzMIKPmsFu1TBY7Xz3NPHiEYsmK1r6ey/jQtjYerq69m1Zy/PvXSESMLMvn0fZ2ZWo6VlM6mUTm/3BjJxlbyaAdnEt77zCJu3h+jscfAf/vtvIgsixUqZUGMzI2Pz/I+//BIrSyVefeksLns96Hb0qoO56QxrBtZisdko5EtYLAqGVsHlUsiXZxCMLLHoDNu3tVFTb8Fd48cQStidDlo6e3n0iX/B7nRw+uRRZMmCw+5ly6bd3LX/nRSLRcrlMh53ALPiwNAUBBRW9a8hlcrgdHhZXorj9fqJRCIMDZ9CEMqUihX23b4fs9lMIb9IJTeBpqVpbGpAEOwYWMjkK2SKeURbgHBFYbmQp2dgHXklSMXawLHhOTJlkXgyxbp1aykUCkxH06SLZlrb1+F025GtJlyBZupbO6mt9WOiAuU0VouEIUAoFCJTtREWfJzOBHh2xky5Yx+RWAJ/QGHfnp2IKFSqAm2uDPMnvsPS6W+ypTXBLzzoYkvfDOHlBPVNW9CFfhIFLw9/8LdYXrTQv+m9TIdhOWlw/MwILref1n378dU0Eo0nufvuOxGECulUBkWE+vpGuju6yJdAtgbRrG2kjQHyeBibvEA2EyeSNqH5V3HLXXeiiiVqfBq3bGlmJXyWjq5aXj88yL0P3seaDevo791IePo8s+PPcfHUM7zrnbeSTiTRBRlDFNGlH4Tauzoc3rU54EVZQlZMV+bIpcybb9Hd6HpqgZvZ5r7VLe8Pc9C/nvrgem3fqI2r7/nK+K843l95f71rry67ct1PCj/qNv9fgA8Df3b59Ymryj8pCMI3ga1A+oo64M1gXF7UGghX8jZSVgwk3YxsSCiSlZJaAlmkvt2D2WxFzIfxqLOUsy9z4exBtvZ1UmuRUEwNXDyvEQ57KKomBvrcdPZa+dY3H0U0hYjF2lFVGae/i6dfOs5SNsW2XV0kim4cODk3nuTuezYyOHwMowgHvvZplhcvoGt5ZheiFAwPzW1rOfDiy7icQdwuL9VSErtFwmmxEs+Pkyt2ks0Cgguv00U4MYnkdEBZI7NcJVsWQbiNC+cnae1SOXDsAq8dnOeuez6ATS6zY80e/v5z/4RouCmXIJUsYLGYWVyIMDkxx9o1m0ilMkyOTxGqa+KRr3wbv6sOh72G9es3IplMHHz2CUqVNBsG1nDm1GH6uoLkC/Ps2+kmnyrTaHMjzUgcvpjC7neTM+yQ16maNRxKiYXwOKK7l5KjDlVUMVAJOPzEolH279/P4OgMc3NLiGlQCSPJVvT5EqJcpJqfIOhQcMouVK2IplgYTkLFvp9liwlRHsCiy8Tik/R7XThZ4Pjh16kJbqBaNvO+u7P4fLuYGjnPhqDA8aOH8bftZc997+Zr34kgqlaaGzz8j7/+I7Y6fRw4X8sD7/w5luZPUC0dR9UFoq8fZHG+iqaLPProo/R0t1JtEPC5LZw9M8TFc2USxQyeNj8L6WaGjrfiES9SY6+yqTtEUtrEN05HGDryMm1BLxZ5jsnhIer8LaRi8J737ufE0BFCdc2ceXmSupCHWHoQv2kzR0aPopvXUBatl3SWoop4hUeuWgUZb5gDP0jOKf2IE/NaXCLgG5PwzRD0zeZVuhY/LiK73or2Zq+7QqiS9ON6ojfGm5KpIAjfAG4FAoIgLAB/wCUS/WdBED4KzAEPX67+NPAOYAIoAB/5twxOlUUMQ0BUTeiCgaqDYrYzMTuGz2nFhcbaTjt3772V7sZ6whcjTA1OMZmSef2VowTa30/I38lC+DUqhaP8l0/9Pl9+5DjR9ADhlZPMnHqFbVu6iC9neey5F+hfs5HJcAJd7GPwbBGbOUZTwEMytsi2TX3UNjQTSfgZny2iinU4HVVsliKdHa2cO/sCiXiYHdvvICsvoAgCkuCgWq2wuLBCqK2WSDqJ2eJAURTSxSyKYsZmCVLXFEVPO/AFBy6t9Prq+OZ3Pkt31xrGR8OsLMfo6m7BZrOhWBwYuokDrx7FJFuoqFkujk6wun8jLpufhfFlnnrqKSRFoKSlsCkV0olFvP4WEvFZbtnWyeL0IQqqyolTL9O56pM0uHuZSkWpuASUVBRzTZmgJ4dTz9HRtYcFcx2xcAzZXCWdyiIqCi+9+DIVRyMlzYNdMSGIKVRDQlQC5KsL3LG5Hz0+hUuQOTWRIotMylqPyCZUy3EcBRFXSaZaOUlOaKbWb1Br8VPQJATJxsjkP3Bv/0dZXqgQiZbJ5IJ87n+fZtISBWMPbQ2NSJxiYGOA0tQkh4ZKLEReYN0qJ3aTymsHDjJ44jwOdysYUbo7mlEMkXyqTK3PQ4ES6cUEum7BbG6jZ+AWHjtSx9otMsdf/GtqOjVyQhslvDjcJe5+Rzc1tRdZ3aTw/Auncfq2kdQyWBxmTg6epVJtY3JuheZ2N/MTy0Sz9UgerwIJ6wAAIABJREFUL1VNR0JHE/TvU9pb1RP+W3CJ5ARuxGs32t5eTYRXE9HV5Vdb169HnD8sQ+hbwY8aZeoKiV4h1bcbb0qmhmG8/wb/2nedugbwq291EIZgoItVRANKpTwmScZitiBUJS79XlepajqGLFIRBFq9AUS/hJ5zMD4zy77SONGFZ2haV4uvuQvHqX34p56hsvIU46l13PPu38DtijC99AiieJjBoQt09NvYt/sBTEqazRv3ktdrWJFeZEtDheXFOdq3/RGq7wV0RwqbuYmZ5WUuLGQQJAcF1c62ndvxCEX6Nq7jLz/9aZrMtcQmIKNnSagxmm0metpX8crwMo5QH5pJQDGHKeohEpqTsLOWZLFMnS3Btr5anv/qYdb23sa/HE4xMh3llt7VKGUHZa2AzZLn6KlvE3Q3g7OWiYWDfOiDD3LolVeos9filJykFmOUXCLRkkrj6gGmpy6wds0AplwSwbuGmYVZGnwFlmZSJLV20oKLiHs/MxNOPI4MXa31XIjEMZlluithLNUM05kiF0ajVCQ/Zc3AECVkRzuLKZ2ypiJVM8h2BVWTkHUPCAY6YercFizZl9jYHGVpbIy1TZu5EHfi0ddQkedwalas0gSyu4bR2E7cVhGr1016ahaHXeLY+AoS+3HWeXn622fZsbGD+z7230g89jonjks01gdJLBzl1l0BTNkkiZyTW9ZUGVmocGEyzraOIoopjVWxo3iD6BWBbbtvpxRP4rL7mbm4iCU5SaXHw+5VLTR1uhg7/Q0G1kp4nH7u/sAdmAJR1PQyCzELRnSIhaE4OdcM55cHadraw8yxYdL5MrXCGqSMjWVHhfMLAVqlfczkolSttZi0PIIhIghlzFoRQ3T/q+/+G/R9V5GscSm7+/fzvV+BJPygztVkJdxwKktXJucP2r7qnPy1wUiul4Duakq8ZkN/1Y1c1eMPIe5r+3xDa1eXX2WAM4wrPV1f36rrOsLlYKxXtyEKMhiXrpdE0xv6+YFcf6w/Cn4mTkAJXPoARAMaauswCSKVQhHB0C8Ll0W8JEqRfHGFihbBE7Thr+/H6b2V5RUbK5Eq3/nuoxSrGSS7iZVMA1985BBPPn4OpeLDXC7z3//j/dQHZFw19aRED4uqTFaXEXEwPzdFrb+eVCyK2RJizebd1Pb6SOZNLK9ouF11TI5NoBpxmps385WvPE9P32285+O/Sf+mLSTKMrW+Vk6dGOPCxWUKegCTZzWSZwCzbRW5ikhF8JGIdmIytbBrbydkFrlt+30kw3Ps3OCmv60RqbqeSNJg29oBOnxWtq3tYceeXcwvxrjtjtsYm5rm1ttvJZ6JEU3FsNoN4okF/DUOTp85zq//4R9itdjJazWcG01hsbfg8bZRyAmoZZHpyQh+a4V7bqnDp0SJzE8iS14EswlrJU5uZREMhRJeyqKAJlnRsFIo5bE7RdxOBzZdR9E1BENFE6Eq6qgSlBMGKxMmSknYtlmn0XGKRuYxiVVkPY1PzFArhLHEB1kfKFCsWDlz7Aj51AKCuYrYGOR0sp4//dYFzL3vpujawu/98deYmc1TH2jGriW4e73B3ZtVlOJpnLYyH/qlfbR3udh32zaKWYH21j7aOpuoc3r5+fd9iNMnBhm8MME3Hn2CgydOE2r1smXHenxuC+QTUI5ixE5Qp4QJiDO0OufocA/yGx9w4pTHMetxzEYAs9xDR/ttJDMmRJuNcCqNZKnDbN8Oljs5ecGHJq6ipNdSrAgYmBE1J6Lqu/53/99gALmy6vpJ6gX/H26Mnw0yNUDSLxGqUa5SSGaoFEoIqAjol5OViQiGhGBIyFYnAV8diixisfr52y+O8pkvJTh1TmF6psj6dd3s3LuZvi2b6d26EcGpEUtO0RhU8Chz1PtfIijMkIssMT09Tb6yjJ5fIDM+DqJONZujzp/n1ReOowt1ZKxhdt12JwNr1rE0M4PXbWHrllVMLlpZioYYn3GiqRaixTzB1nV4ne1s3vIOytTgb7+VqVQtZxZriSzmyOUXcZh1fNRiil8kKDzG6YOP8NprJ2lrsdDdcBGfeZnleSudA1uYGjvB3j3dNNdpfOGRv8YXqGcxvEwkFqa7v41wJI8v4KWzO0SpkqRSzSHLIl/7m7/hxInTHDs/Q9aQGByfZmxqAlHRKJXTFPN27ty1CS19iqAzh6CXKVXsmJ1WauUMyfACsr2BirWdgqRSlVxoghNFUdHLs9x7+3ZshTzWagmTrKOJGqp0aTsruUzE1HbMzbdRv6EXj98GcQf+xhC6aFAup1nd08B9d25FLCyxbYOHbl+cTU0CWnQSk2zDq5a5Zd0tzM2pPHcsR1ZZT960GiFfYP/mBj56jxdz9nukll7GU+Pic//r64RCfk4ce52VhWVS2TkK8nmGjj3OkVe/y8LcCDMLYzR11bLjjo3UNHaSy5h56dkzJC7GOPnSESRRR9c0JsYnOXrweXZtsqMlv8vH/78HaOho5R+fmufEdBd//pUpip5dmH0dOGtrsHi8DI7EyQk+TPVBKpqIIaqYzCUEoYBkVJD0t5bD/Wbwkwje8f9w8/iZCMH353/12U91bHzwkvO+riGIAg6Hg4pWRJYEdBXQBUQkBCQsFj+ZeBqzLJAv6GQrjZiqEuXiNJVUDCmf5/z511lZcRNOztHbC60NC/R2aSzNDrGYjlHrasetdbNjcyff+OdP898++R/Y0GonkpxnJRpm3x0NvHPfgxRSBVattyKW0ijCJAcPPIXP62FwbJ4DJ+ZYtf4+Gpr66GkTOXnqAEsRPw6bhMfpYHYlSUZpwRFaTTpnpskVx2JSKRRKmKUyPZ4p3r3J4PC5MQxvO6qRIrN0mng0jGpSaF/VweTFc3R1uplZmWbr7r2omhOnE1b1hRg9f5zIQhyPzU1FzRBqaGdhKYVJsaKYJLLpGC0tTTS291IuxyhkLxKOrdC9diuYBzg+ucRsokI0r1BVGsgaHqT8HOXRlxECtWTcveSNVqpyAr1iR9bMiOo4Wu4CRqrIB9/3Pi6MjZLVdXRZRjAMBE2jYorjDjZTsXs4cHaeqcVWoul+UpVlXL4AZkVm+OI4p2eT5NwduNRhPnB7C5ZSkcRyFqu1lg/0FVEKYXx2C+F4mWRW47bb7iA++SL5xASPPvp39Ayswlm3jtPDAr/0ic/wla99id/+5IeprAyzaqCWEyOHafS5icXnsdpktm7dSLGUp7evjfHJAmeH8uzZsI9kOElzWzuWUB8HzoaJVAJs3vswT37vKbbv2Yiqe3n51SnK1o1ETK3gbCYWL9LfbKWzQWJybJCezbdx7Pwx7K5pPrA7RKUYIZHNIcomDEHHEMvowqWt+M0Q4NXuQlcTrnGNRfwHdd7oKnTtlvrqfPJv5m71r/r8ISvfKxb6q+9JvLznv9p96WZcvN5wQECQ3uDBcKXO1ffxhrZF/lUbgnB9Xet1+xNFpk5+9f/+eKZ/9pef/VT7lofQDB3V0JEUE6IsoetlTLIJDAFJMCMggS6hUUXUU4hiBEwqJaGRSmSBu/bVMz34OtZKjnIlgyRtpclqxmFNImhzvPa9Q+RK3Rwba+DEdIylEYk1q2ooCxN89/GXue9dD1EbspKMnWfb9iy/94lP860vPcmd+zuodcwQ8FzEqmikMgLT4QB3f/ADPPfiIGbZzOqOHN/++pdoDt1KjizFbARNhJaBW5mcj2NR7GTNLlSjl7zuRFemaLTkSA8nKNXv5VysQHRRRZstY5JElrRhRofhzGgUT1Mnz710iuxyhZGRE7zrgVvxewS6mkOEp+cJ2BoZm57C7gyB6EQ2mdHUEv+Hu/eOkuu6zj1/N1XOqatzRHcD3Y1GJhIRCGZKJEVJVCCtYEkj57TseR7PyNZb89ZYlpes5yfb8tPYsi1ZshIpUiTNHAACIHJGoxudY1VXVVeOt26YP0DQIA1IpMTl4fNe666u6nvuOber1921z7f3922BCuQlckWFerWGVk5itUfJ1gKU9ShTRg+T1W4EVydlU8EQTbzlGGuCEjFHE0l7Ow7BhSZnkFUfVlNGUM9x583NzJ+ZZj6TJ10tU5MtGIKIbJhY6yYdoQCZXJLpxTKLsXbyFSdyoMwmSxq9Uqanq5Px+SSar4sFs4HkWIqLo2ewWG0Mbxgmu3yao8dfpm/zVqZTBdIVnVu3DnD2hW9h0S7ysU9+lgNjRdbe9nm+9q2jjE/ZKZXy+MNZvI403/rq35BNWLn5ls8gkmbVqiHSyyrZhMrCVIKTh85jWK3s2PsgI2cuYFHqrN7USVEvU9StFOs2TNnLPXfs5Mhz3yc2bXD6yCia6MYV8bO8cJm1DUF2b/PgMS9TSsUo5CK4XVHawyJrrYdxySGWkyHytRA6CppsIAnyLxxJijeo17zRJvPtMIx+lv00jFOSpDcSVG84qdfPv7X+853ZjUWmrz/8evf4ztb8RZ3pe2KbD6+3p5UEBFHEFKBcryEI5pu+ueAKg6KmlhFEFVMoYnMDikAgGObkiWM47QqFbAoJCY8zhENVSEzOYREsZHN2CsUmwo33cMuH/jdWr7+ZkdEp7rznNpq7u/iNP/xjDATCYTd+T4U/+cPfoSUSRdA16tUZrEqKfbetJbE8w2c+9Tssr6ToXTOEYrNTLuaQgdjMNNlCHqvDSm9vN7H4AuVSDq1aJi82UhJWUVPauByfZ/OO3Wzf8iAjl8vkNRuKtQ3JaMPUXTQ0u3DaIgSia5leApe/j8ZgH36/nVdefpp0cgGHy4qg69RrdXq6V5NJF5meniOdTmMYBg6HA71sQE3EafFikb1IkpdksnzlM8aN6eulYPgRbT6sNgHFNNF0AdkdoqyJmIaKiI4oCIgINDX42bpxiL07trCqfxVOjxNReT16MEE2TMyshl4tU8hVsNu7kW1u3MEa1cURBpp8jJ05TjQcoVRWMWUHwZabCXbsZCyW5cTFM7S3K7hae3jt0gTh7j68QS8KBdTUZW7ft4lsqYDo6eFLf/0konsNTZ0bmZi8yPCGTmLLk3zw/o8wvOZu5qctOF0Rmhp7uXRxjvhCkcR8EQUPzS0RUullgo0BivUiJ84fp60jwE03DfGBB95HYmme/S88h14tomaK7L1pCy5JpSPq5DMfex+7N64mHLYyN3WWWj6BWNFRUzVsqoJdXUKpFLFoVkTNfoWfj+1dKQ6/6rz+I0p93q79RxAB/lew90Zk+qW/+GK4fQetrT0UKxqyaKCgouoVXGaNejqOxaLgjfhZqavIgowoKoi6FbEm4xTyzAhOTDPK6s5hHOIU4bCDGmVCDdPkixUm5qOsiLtZ0DpZVp201QKcjT+HrcHB+LEq3uAmzOh6MvkiN61qwW42IARFHvz0Ti6dO8X+pyaw2EKMXJ7j0tgixXyJkYSfekrgvtt6MJTLhFseQnNEWO32cscdbUR9q+ho7WcpNkJJGwZTJF4WkRSBX71zmLlLL/DI/kep+27BUR/HqD6NGZijKKg4rKuJp3IMd4mkJ8eRawo1RIoVCxs7hjlz4CDtvXZcbU5277qLkbNzFAtZRLmErhcxTJ1qRaSgWWny14nF5ghteJhXR0y87jbCNju3ttcIuWucT1YRTBFPOcOudVaqmdMkxEFKyhAyFWSxAfQqkbCCrFkYOzNLrZrm/GKWQsWFqvnQ9CKiWWawt5+V+Ai9zZtQawrxwiXC0jQ3+RRmxh8nXaqQdq5mmSBb1kR4sK/A3oEVCqklehvbkEQ/z0/YkH33UqpbWZgdZ7DRxt61Fh7+cIgWIUtm8Swbh3s5f2ESWXEQy+YJtw4y2G5n6vQZikmTueQCd31oPV23hJGqJb7/o+fZdvMerG4Pd77vXsID7bz05A/pDdSQTJMfvSyRXojSO+glWzjC+LkLbN9wF4n0LG53M9FmmT3bu5k6+QpqcYyNDzSjZopcnpmhqWMVbo8f0+phIVUjXrJzaB7y3hYKogFKDUWsYxjCT20od6MI8E3N8N7I8l/5aZgGhmkgvCUuulq0fm2S6kZrvhOW0Juy5a9Hx/+uaF8QMAXhGlLClczHtYcpiPB64GTA62OFa4gNb2aHCZKIIIkY15AcDMw3zl/pCiC86TBeZ5Nd7WpwlYGGcf1I9z/FNv/b3/r2F3t61oBewRAkdMFB3XTiVCpQU6lkUgTdNgorC1iNEprVhoEHwfRS0wVkpUrG9GKoSwSCWTZtFgk2eZiN1SmUW7icsLCidFBz9TEZqyJbm6nWssiRCIrDS29HiOmpYwhihtt238z+x55BoZ1HnrjA9FSRegke/qP/Az1fpLFzA7GUzNBNHydXlqhmsnS2CzQ02Xjk6SITeSuN7goHT/2Yxx9/GacvxB337+bF/WcxaMTmzhJwLPHJO7s4d+AF2lv7UCw5bPIcTleZcqVOtKWfQhFag+2s7mzHqMW5994dpJNjXFxRScVjKJKFhtZW3EEHtewogx39LM3OocgN1KQwireVstWNs7kVNb2ETbIxn3ajuXYieTcTNY+ysnSZSDiM0yIjF+PY6lk2DTo5d2mUvH0dVULY9SpBW4aP3trMzv48ZI9xcnSZrH0fRbNILAdVwUbdKOH3OEnMLRFwu1FrObLleXoGIgjlHGqyREFbZHD77Zxd1qjZPKQyMaJBO13CChfPj+KySUxMjWK4PFDoYnbsFPft28J9N/fw8mNforc1hSSpNLe0cfjVCzT6Ijx07y2MnnwMxbaOI698m/6OJkZHFtl734MslnJ0dcjE56cIeu04jBDnD85RTYR56vQSTR1+CrlJRsYnqMhNbO5pIhE7TXPITr1Qx1RldL3OQI+PkfOvkknGaG/uYXFmkmafhXOnZpGFLHZ3hVCPjTOxBeJ1nYvpYTJyD2ndhy7ICMKVWlP46VJxPw1PvJ5diyeKvBkzvSpGcq14yY0w1XcSUf68Eei1+OWbcc3rt4sWxTfjrdfqrL7Te3nrGNG8/pr/KZzpf/u//58vfvefv8VLLz6PphnUTSv5solutSEqPmSHjxoSmXKFoqridDtRa3Zq2hX17Lqapj3oxaEv8cBdq7Gapxk99QJuU8Hi24nqaOd8wkrd2kwo1IykFilVReKlIPmyFUVNsHUwyqmj+7nj1l607BJHjpxh1+33MrC6n1o2RXdzkP2vHuNfHtmPJrYwm7IxMDBIMTnNpo0ufvN3f4No928wUZVwFHPU9DQd0Q1oVQGbzQTVS6lmw+2c4nMPbeZLv/0pBjt6SReLWLXL5NKX0aljc0SoVhQU2U8VDz0DOzDtNc5ePsG5S+No9vXoJQ1J8vKTZy8zn7SwemANI7OvMZdMI7i7SaldTKz40HzbmJ+tsWHVMAuxAo1Dt5KWI8ymc1QrOiWpiVrVSnopia6CJ9JBQLhE0d7Ksr4KuyOK08jQVH+O7Z1zrI+cY317AtHiJdx5C5PxJUzJh8UZRJCqSKaGZEjY7C5KhRShJhclM49dsGHXvSxk8jR3b2OpEqRghjE0C5fPT3BiNk/F2sDyzAV2b+7irj09rCQP8UsPdlLNvsZgpx+/w47H5ybn20ld7uMf/ukVQsFODrxyAEOvsmXj+3j/vgZee/lHbN20k4n5JQQ7vPb0TwgEJLLpi3isNfweGbdDpKo1s3GjTEiJ098Swe4QMKpTDKx2sbx4jrmpEbr6V3FhfAZZrzK/OEco0kg00kUmmUJUM8gugYG+HpaWFlhIZ9m0+7c4edbNSHUVmaqM1e0FQ0MSTNRqGVmxvSm6uxqlXvv6Wgdy1a596K+lhl59L0kSAv+m+3nttT9Ln/Tquau01WtrN29EC/157HrJoCtzvjmZdvXQ9etTYN8qFP3T7vVaQeprTUS47rXTJ7/9nwAzFRW+/vc/Yvv2rUgUsIkletuCSLKDqmBFswepW3yosptQaxf1UhG7XcDhlpEtEtStNDglwm4fxw+PMDGWosEXYO/mVezbO4DHpdDc2Iss2KjkFvFb5xFEFVEKkUgrFKs60bCHdT0djJ5+mXTiLH/8X3+Zv/v7P0WrpTl74gjHDr9KMNBAe+sakqkyhWKVD9x/Oxs3d9HV7mTn1k0sLKRp6+mno2uY5HKZnrZ+qukch575CQGxhJmboBA/RWz8JDOjs1y4NEnRKJFfnifo9ZHP1LCIThpDTXz8gQ8zF5vluVeOMx3PMbmwjCAE8bsbcXl9uPwhDHs/C8UhvvlEmv0nZ6lbXOTKKRArWCwymG6G19zOuYka63Y/zFLFQb6uYZol4pY1zGidxLIiG9esIuiWyJQyTF46z+XFIhVdIZ9OglHk85/+MK2NLkQ9h82jsWGVjcWzP6A94kUrZsitxJFlmbpu4vT6yWoaFV1hKV6mWrPjDbeT00B2dHDs5ATlokmtJlOtWHG6Oqj5h0jUnVTqNbKxUVIjz3Dv7SqVlcewiyMsLkzytW8+xxOHVB4/JHBsykZF8KHYbYiiSMgf5fKF5/HYsrxv3yDllcsEbXUS06P4HA4aggF27dzCxl1DtHRYsbgT9Hf7kcwExZU4EbeFqDfFwFCI5dgkMhp7927GEKr4op1U1AZEexurN+7m4uQcqq7j9TjpGwhy+MBx1IKNvXd+jJmRRbILKg5ZJOy1oug5RKOMoVZwOf+tYP8q5nlV1Ph6dm3i6GcdV+16567Ntv+062+U8X6n0fK7ZW93/Wud6s9zf+/m3/OeiEz/7C/+3y/6O3ZTqaS5/ZYtLM6ME/bbMSsVhFoVQ9NQLMKVDo96iezMMopLQ1RqUC/jMj3osko2B7mCwuLSPCI5mqMeHJYic7Eqp0ethIONWKqX6AuepiKJFPQQdqeVD90dod0XxypUMHJ5qM6QLkxw+13v58lHfsJnH/gkp0aeo7OjD0P0UzNdVHQHT7/wNJsGfYT9S1A3mF4aYKa0jBi/iGBO4BEsNPtF2lpULEadQrnAH/3hB/nGV79Ef2gdFVOl7Mnir+jUdInPfO73GL04y9LUAqdefY3ODoVSArKJ8zR6TPxagEvzcwz2yzR22Nl4z29zaDpKymynpSLTEWllqFuAyjkcLLJjYwfPPPcahtXByQWVhGWIWtmLlKkz7/BQV+yEtCkGvdMEfUWcjQqVmXGWnBvJ6o24bTI+OU440s93fvgMzx08RzTcw1NPHmLz4DA51YZDceENNFKs5hAlkXIRSlIVQfNQ130YNj+JZAKfx0kiNU+kIYAtFKFgiNSrBRS9hL8Ww6Xn6HevsLnHSjF5hrnxQ3Q0+Aj5Gqmaa4iZGzi1EsQUV3H0tZe4Y3cDpcSr9LXZyS5Mk1iZ5n17LTS50zjVGn67DYuZpq29jM9pJblY4eThOdYN306+oCA1eMCfIrmYxu+J0r4pTHpRI7dSwa74mVtYJtKxjcl4iKVZhaPnJzkxMsmGLduZmZuks8vDcwd+jEPvRdG9pGOXGJm4BIbE3FKWoKOCWUmCqeOwe9FNO8brXKJ6vf6Gg7sRfnpV1OOt6kjXO0RRfGObD2/e0suy/O+y7W/X+fys8e8kUhWEG8VtN5rjZzvTq1v/q7TWt+tQxbcseXXsf4pt/p995a++2LvtNygbIS6NL3DvbVtY3SJj5JcwS5NYtQRBScKhyZCVcDSFsBRLbO3vplLOkHfUSRS7KJbLeF0SXqtI75qbOD1T5OT+eYr1MaK+KoFyAz49S632TYKsIl3uoGqLMrJwBp8wQrccZzYzzdT4GP1dNk6NnGHjvof5xBeeZONqF3ppgvH5Ii5vL8mZObbt2Ye6kiAcklmsy4zOhdiy1saw9BxLc2XCDTJLEy/hsrkJrfZhn36ZqCPPC089x+yyxPY7thFpqKGq67k0c4CJy+c5d2QStZSjq0/B705RrRzDKhYwDROb10E+d4nf+b1PY7E7mVlSmcz6uFSO0ulowxMpMdA3y3CvyLYdA1SXL5KqeogJUWpyGKNWpWiqrHiDuKtr8dQv41MEREc7YwuTfOaz63n2wCwJaQi7NYRQyVGvGUxNLlFJztEb7WZuPohoHWRdfxS7bOPUpSk0WxChqGLVQJMtONQgulRAsNbRKmAaUJFqOFwlcok0huGiXKjSGrDgMJZYpZ9mtb/A6g6JcnmeC6Ovcu8ntuANdxPPeDh6wWAqY2MuI+Kz7WffmjR3D1fZvL6P86fPM3vhMl/4Px/AVUmhVwXOxVZIVitYTJWzYxnWr27BpSUoxVTOH1khMRPgb19y0ti+lZ2b+ykUJ9BtMcKrezn0dAy/NAhkqfhD/Pfv1ilZYshBF+5QA9MLC2y7ZT0zK4dps9rIF2qcH4sTaNjO9l176eo22LPRQ8S5wr4BH6wsYJgwX7LiKddpFdqYr6YRgxbCZYUaNsr1ZrJmiLIjgyks46z4CVTrVK0aZYsVqRZE1G2olhyeao2q5EI1QdZLCBYXK/jwEkcSasgCV/iTBpi6gSldSVq9oaDy+vlrFamu5xzfmmi6Ls30mvbJ13Os19aEXnv62q21JMmvQwBXx1y5ybcTmV5LpxXF16EElCvtrU0FwzAxX29jLYoymFe0PkzxGrWuaxJT08f/EzjTL3/lr7/YtemBKxk4tUKlmOW1w69RKqfJFrNs2LIRHZNA2IfTZ6Oav0Sbr04ufpZKdpyOFoWhhiJK+SI2PYbHZefSZIacGsViTXD3gzeRTE8jlHUcQpy+zhQXJqaJdt/OYlJFLybod+UpjF+kbVUjN23ZRkEVCHVs4eXD86zf/AF++N2v89EHb6N//WZi6WWWYqdYu2odETmPz5bklcOHMYxN1Gvz6CvHUQULggCbBtvI52YZ2tjL7p3384+PPo09uIYdd/468+k6ht2DszpHV48Tt9OBiJVgyEO5miEcihDwh6nUNLo6e1lcSFBJSJRTJSZGxskmcxQKOaxKDmklS2LuMGvabJx7bYSO6CAnT0+RrkfIaEHG5/PYXVEMe4iS6EYSY+hKFk2wUlzJYpSXGWx3cX60yorZjil5kdARRAM+RHybAAAgAElEQVRNN0BdYe1QH5IjTHvfOkYuHOX8zDht67ZzbDyGbFXQRKjICoZWQrTUMEwVu8NGTVWRRYV6MYpUK2ER4uzZGSVqmyZsnufXPtXO8GCAE0dfxOUQaWtpI5Nr4W+//irRpluIZbw0dPWjChXk+hxkp1i4fByHO8jzLxykrakNixhn6fJJErFFvE393Lzvfi5fHCcaHmRp7jIGGv5oH5q9kYlkjbS7lUtjr9EdhLawj/mZOA7JxfjYPHVBpiwGqIrN6IaTBzYE2bd5DdVUmk1rdhKbWyGZzJFI5snlbIQj3YxNztDW00LP6g7CoszEhVFQBbJ6kDk1wpylm1y9SMC+gFifZXWznTX+OH0NZ6hnx3DoK/jtMmJJxE0TuixQUyRMUcRpioimSlWoIUsCZdOKJIo4jDJCXUWSLNQFAw2Fugi6YGLKJigGgvnvOfuicH089ur7nwYFXOsIb+SIrz/3z46If15M9moi64ojviqALbxRyP/v4ZDrr/OLOtP3BGZqCiaGoAMastXLxYk0vsYNCPYofYM3MzKVIJYrMDo/SbqSQjfKZPMxBte0snGgDaW4THn5KEsTr7J+oIWtm2/CY29koHsrv/UHv01ns4eF6aepC+eZTo2TYR3tg8McHzmHxRnE4V5LUQvjbmlH1DSKegMNA5/g+GUBm7eD5cV5njs6wj/98Am+96NHGRpeh2nUmBg9joiKzWLBZvGzklFZSOZoatlKslKiInVidfawqquRyWPH+MY/fZUXXnmVzr4+NFllbjmNTjuCvEBPVyeFQhFfyEpPXwud3V1kcjYkOYphOEksZ8lms3j9reTzHi5fKOERRVYH8vRK89jcMXr7mjh6cApD7eCH3zsEso1KPolkGoT9AWxWK7VKgXq9gCSkKMmNxIQuVjSFvu4uvvPnXwaiOJxhNE1DlGUMxUHWcCIGOnG0ruW50/P8j28/QUq1ocounj98CsHupybaqIk26qIVwSVjilbcThfRgIJWrmKlBUXpJOwyiQhHMSb+GsfcP/IHd/moJJ4nPvMMD3/+PnxeC8g2tm3+KKsH38/xc2nGZtPk0jH03Bhe2QBVRVVFnnjmJfrXDqFYBYaH+vF7fVgcXobu+AiPPnWKjoE7cdltWK1+PA1rqLp6SSptXCg4sEVb2XfXp0kkqlw8N87UhRVOvzhJa38PztWdnFhuJBi+nU9/YICQPsXs8SeI2kT+5q9+wMiki7z8PmbLGylZVpOuWtFNnaf/9VGq5QLxZB2LHETN14k6nRi5ZXxCkagzyQO3lrklMEdX4jQd9lPcsXqMX79L5+EdEjd3NNEWbKemQFmxYZgO7NUq7vocbnMJC1AVQXFYkAUNj5GjXUnSLkxjSiEMxQeyF0Oxo0kKqnD9WtQ3oIG3FP7/NIbU1d9d24/pnWgD3GjuX8Ru9Hdce/4/At+9aj+vnum7bCYIKiIKiiQTirSC1YnL6mRqNoUpBq4U9QsmmTJIjn6qZoFDl7LIGIhikJoRITrQz8unklTTZ7ln7yb2bm0kf+YA88njCEUTayDCTC5DfLSJxrAfe+M6iqKXXLHMaCJPz6YAKzOLjE/G8a9ZTbLqIbOwxJqWXkbHTnLbbbcxPi/yz//4LG7LMIlihcVMlajpYToDVXsLckDA1FOIthCasIb9h47htlxmx+Y9BMIJJKeHzmY7J0YP09/uwCWkEV0WxmfSrN98C3NTY5iSRiKWACJMzcYRTQmrxYGIREpMY5aC2CN9LKTr7Nq3heTLM1gCaQyxQKQ5ilms4wmHKWolRFmmWirSEe3F6baixxewKDnMlIBo70KyegiE3OzZ1cNzo1YW7BHKqkmtVkExNWwOG6JkpVA1cARbMCx+bF4HwYiP3GKJcCBKVg5TSi/jc9tQq2UcIR9iSaWeiyFZc+zesJqlOYWSeIHPfGwtEaXOM499G3JZXv7hozg67CBbyKdfQJREwhE/rxz6Npt37uD7T11EcbqwiGWc2gqV7AJ+a43e3n42772P4ydGeOH8Y4ieLkzXPOV8jb/+6nfJayEMuU5UXqS5zcfUXAx/81oqNRvhSITFPCQWKxSWJynJI0SifnJZN9WMSDDUSqKSplzSOHf+cZYu7+dTv/3rPPLIEZoHNlBxtWH62pg6P0l3AGpqHKddwu118j+/9jVW2I4gBdi9dpjM1AyrbCZS8Sh93gLm9ALC4hK33/FRctZJrK4uRKGZJkcjJw6lSVWsJKgSsIVQVAOXmiZqTWDKCoKtnbSmEI4EMbIqyYtH2HPnOo6eP4nLE0E3QLbZqZsymmGSy5Wxuq6oJV0VWb6C1d7gKbwB0+hGgs7vBD99OyymtyNNeL15rgdPiG9xolfne+va76Y033vDmZqgaDWcFgmLKODw+FiIx7AIdgQpjKpdKbo10DEFjbppQ6KCbG9B1E1MXURwNrOiZlGcFfT6BV46Pc0T//oElaUp/uuffJZdW9t4+WQBu38Ia3QXs/EkRthFuZZGtolUpDDWcJSJI6cJrb+Px05mePDeD9NuWeblb32FF595hU/dt40X979Ae+stFFN1NGWF9/3Kr/P4N/+Y+aSG0tJGXM2QLSuMzc+Bqw0tN8+GgRaml1T++bEn+PJX/p4Dx05w294OTp8+TSYxz4xhR6k0kUyXySQmCXhEuts72LDj/fzgX77J4twcpVIFu83DTGUZvdRFNNSJ3VulUM2xspSkUqlRtGYw7MtEXGFyVZHL83l27L2ZQfcWPJ5m/vR//yyf+vQe0lqWqYJCWXSRr1hxOSdpbukkUTRYVBXqEni9EvXcCqZsYpdsNDc2cfHCJaxONxuG1pNL7qc5vJFUXCWdXuL9m5oproxzeeoS+fxa/JpIg6/AyvwPiS83EXDu444d8+RHjzE5dZxmXyMWb5D45AQWxc5SfJR1m/oxTZ2OnlYm50+SnRbZd+dufvLCKPfsvYnv/s1fEe1opLoco65H+PO//Hs+/MFP0d09xG/91Vk8ms6W7Xu4WFphpWhjrmSwMziHWpOol6vEFl+ianSjFCw0eRpYHlX5vV/eTW65REm1carURirmZ/FcEotgoNUukI3Ncecn/oBv/ssjrBQEujfex4sn4rj9rXRufAht4UWcZg4HKh6sNLSv4lA6yEg2yPiBJfa0KvT7k/zGnl4sVQsHLsKu3cOs7m3muXPz/M9vefH60xhmjFjKRsnagjUgoxfmsFYMbAuH+cgHG0mrOv86XidTbCHcUmcpMcYXfnUXLb4pNg3IPPbiY7T1bODseBFX4zDjs1ksssS7oyj6v769yYle8/rd7AH1nsFMB4bvIeC0kk8vI1gEitUChlRClwQMQQJZxJB0TFnDIVQR5DqaUEcXRATRgqInEC0yumynpLSQoxN/zz0oq3o4cSlOci7Nro2b2L5xLTs2raFcKHL84uO0tlnx6naaajAYaqKsJRkvrWHBaGLm8osYydfwVk7y6d//AkLmIu29q3j1xAEiTQZSKcOA145LKVC3hJlcaMUXrLIloDNaPoQj8kEUucwv/1oP3/ibb+Pr/hivntQpmgFmkyPE4jFS8ToF/ypkYS1qSSMaKWFqOeqlKofOnqGQT7NuaAi304PT6qNeUnGbvTQHViHLMywvPYtYTZOV7sBhMXFY8mRzdVz+fmJZF6PTi6i6i9OvvsKHtvrZ1Z/mpt4KTa2X6A76uHVrP51NJo8/+ig2Rw/jSg81i4OQW6aeTTC8ZgCjWkXLzyFTI5utU0zFsVenMLCSzKWwKzl29JTY3Fnkzp0e4nU39dhFhjozPPwhjfvv7mVm7Bxt1hkC1TilRJL2gUEinWFCXS6OXjjIBz56K2fOHqNcriIZLkaO5UnlfGSrLtq6OnGKF7GWXyFTrNIacXLPfQ+SKFg5cuQiPquT17Rb8UX7OHQxQdbaQUWMgMXL3m4fHU0NLI4fZ+NghFUdMjet9+D2FXBbbUyPPUYwbKFQX823L2QQhD3YpWE29On0Nk8SEAM8+1qS+FICt8VDvealUhEYm5omviKjlGexqgu0ucq0RxtoCrewMjPGHJ1M1aM0Rn343TphV5kjE5f47tkWtt22mTPnHqFeqPF86jYSuUkefvgupi6OYzGa0GsSFmWRHb1dbPGsoCw/SsSv4W4YIpZ0o5WyrIpA2DjMhjUpTC5w1waJ7sYSopZk966dDPV3EZufIF13A2/WKhXf4bb3RlHlO9s+//xr3nDGN63/ep+C15sGXklqvTmJ9kYkLb6ZqHD19fSxf/qFMNP3RGQqU0dy1Tm5MEEk2k29YsElN1JwFhBVGREwzDq6oFE360iGHQwTWTBBMECoUbGICEYNDIOA1UbN1KjUUhTLbdiEMIJrgHlLGxcOnkDTJ5gaH6VFjrHHVyEy7MaHi47WDE+OBEgli2xta0TSVNb2NTCvBZk/N0Ik1EFs9gBeZlmcnscviNgaNhBPTbHvls+S1ROkDY0NfTlOpruZKh7l4+/byte+9LtIlTpBh8SEr4tktcT2shddrFPo76cjfYG6eALJ6SebawDBQtEcJ7acIdhyLyv5Ir/1iTv4iy//GXOmyuruQSyNQ8yefoZAKE/e6mDFO4xZkujy6hSKJ0gWyiyrGyi5G9Cna6wO21lMPMLTr6iEfWsZ3P0xDs/bOP/9v+Pje3tYXIgjNNyJYrhpKxRZIcSKt5uz50fZus3P+eedzBTniKypo5ZvQ3daiSgqsaILZyiNzfIj5i6PMtz5GTLHTAI9O7iceo375SiWgpORMZWodZqbdu3j5Mg4xWP7uWnbOtqaA3zmIx9gYnye+25/iEy6RLVisuamtRydkDh4VEXzaGwecOEQB1l03EKlXuW7P5hEKedZPn8WtbEFTzDOqaV+xKgH0VTxFnSinlNsWN+CUJUoOTazLPWytrlCZvLr9Anrscp9ZFvWUA938dj3l1GMXSzkKvS1VSgmRwn3uSj4BNLLT9PQ3IItOMCB0wXaBnfS1VLiw+stlI9dJj97HL+vl6kVlbs2DyMkwrhSDvx2PyfjGrXwGi6/MMbu2+6nQxP583+5wNqOfZTSccpyhs9vDtEUfxGHW2VS8mCpJrCpfh7sPE3A/iwHa3fzlSM60RYT2W4h2ufnyMHLLIz42bBvLcpqF0omj78msHtgiVcPfo5s/maMi33IrRYUl0TdUJF0E7FioNmU6z6HNyrOv9pV9Y33CAi8RUn/TX7t7Ud71ybI3rRdN66fpDKuKfK/NpH2xrWvO1AT7U0U2zcLT1/Fko1rHO4vrgn7nkhABfwuisuLdDe3IxkWeF2yDM2FaNiRDSuiaUM0HEiG52fOJwgCVquVQqGAbvNQEZ1kdCsjsQpTeZmys42u4XtRvGs5M1rhh4+f4CdPHUOrO4nNnyUQaKdY1zCtcUZGnqOSWKBazZKIL7L7tlsZ7O8jEoiAKZLLq1waneXc6bMsL02SXJgk3LuGlqiXJmuBJrdOJRvjtn27SMVexMEEjd4yZ8+cpl6xYDW8mGYYzeykpPdQkvopiqvJC2sJddxHRegm2DDEd773NILkRSsFMOouMpkKe2//AIq9G8mymmopg8/vpqbV0PUCIimagmVaPEnuvmMXo3NputffS7YkEWnw8q3v/IiZ2UVu3rmX6bkkWPwkSxK6KKKKCiIaVqFGwOfmxCvP0N4aQTJsaBU3k+MTiBY3ycIiZb1IIqPxxLNnieUE9p88jsseo5Y/QiF+ALetwPLSee6/e5DBoX7GLo/gcCr4wy7CjR7OXTyG3avQ1t2CJmiopk60pRlnqEC6PEJru0xTg5czJ8Ywqk2kUnFKtQqjc/M89eph7vn4J2gd3Iike/FZQwQsfhRNwWq6eOjDn6PMCFUhy7mxRV49ssix0ys4fWvBa2N8RaVgW8eLIxLRTR+jLIYo1upoaho1l+CHjz7FIy+e5NY7H2YxqXDw+BKNPduZjOnML9uJr9SIZQw27ryHhWQJSZJIxWbJVZpJ1ltJmBEqViunLh0j0mjw5IsHqAkiFpeLucQyy+UCXnWRjqCTqYsjiEUdSxkCtjBetwE2hZLgZ3HFimztIZb00tRl58CrJ2lp7Wdo/Qa+94NR/tufxPiVL6R49Oks//r4abYObmGgT6G99xjr7CdYLY7iyowiVZZRre8eRviLFMtfz94O0+pG6+i6/q61Sfl57T0RmQp6FT8lHKZEVVUwpBKakEeuB7EIKrJYQzYVVGQkUwHqP3W+arVKXa3g9XrJ6XVsDitazc5sRkUIdFH1hlicV/FHdrKi60hWG+V8lr/4y79F1MdJZ+uklQxNgdN89N5hCocDmBadC2eO09rgp6etA7WS4NDICOg+0gmZxeQ5/stvfom//9Z3+KcfPEJ/n8KeVa38zq88QLmWZntvnr7mAnH1JBINWHwSRr2IS1tBxUNVbCdttqApQSxWk0p1kVpFwOeMotti+IIpMtkEzdIwdUNhfHGCYLDCpZk6uFppCdbRSsv4G2wYhQI+Z4Kaepzf/egvUZbdPOtt5Rs/Pskn77yLcyMvEF92E2p2EAmEefypcWquIQq2bjRBoizZkcwiPjOPViiyocFCsTKDw+bhji1345PGSGYT2Ms5dHs3xWoTLYGHSNRipJIlOqJZfvM37iUbU6lkTuG1h9m93sPBQ3OUkmmsTpPdt23m4NEXufWOnazk8jy7/xWctkaKeZ189iD+oM5w1yDff/Lr3PvB32exorOjbw3dkoRsVHFJDs55aqwa7uHID/4Vj9CNXS5SyU9jqeeQSzamLpbYtKdE/EKRz3/qtxiZKrKceBm11Yq70c3R6TSJBCiN65nLaphChJYWA78yhZo4T1a0cDil05q3kai14enYynTRIKPJ1E0fp0Zm6PIMUXQ1sWxmEQUrrx7cz3g1xJLZQsUXoclSpLPVxvZV0B3y8czFV/jIzbtIL6WYmZ9jS1eFvZs2cCRWZb1pQ8/myOfybOhOMTlyjPLMCNGu7YTTOeZWVpCLl9jcvoql6aPc9Mk+fvJIFqn2EBWHzlJmP/dt+gzf+cZRNr5/Dzd90E0oG+Dr/+MnNIQ2k8ZCwWFge5f86Y0c588b413bU6pev/4zfi3Geb0+Vf9/dh14T2CmX/vvX/3i2qFtDKzdSri1E3/Qi9froqstTFuzzMULz+HxCJhmFUWW0E0RMJGkq6KwoAsGgikCErIoIwgmtVoJj1RBrmWxGWV0tYiu1jA1g6piwxArqJJCqabSGVnhD35lG5PTc8iebRSlKvfc00fI2UBzw1bOT5wnl0uxqmsVHo+f+YUkBw9eYvTyNCtZ2HPrHqIhHa9UIJ1IMNRSY3E0xfGpNPc/tJNKLIleE5FR2L1lPYaZw+rIUs2dJatbKUndpKV2SlYXZUFGl304GlZRrZX4xL0dJOdfYt26Np5/NYOvKYLs0SgWJnDZaoSiXhxyFjM3iU1b4mMf2klDyEklk2Tj6g6efG4/iytloo2D2Iwc1cIkFtFJriSyc7iH0fOnyRgRsp6tSFTQsRF1pGlzZPjE/bexcuw5GrpCFGoqjYrCsZe/Qd0aJZdKUxZaKeotiEaYbN6DZu9i+1AXJA/RE5YRzCDnzi/TEg2j2OqcPn6McChEsZrH4XVi97kI+aN43CHOnLrEuuGNLC0m+PwHP0rYKvDw+7fT7FgkM/0sbd4spcQMluo0NjNGwKESm7nA7s3DnDhzDDdx9mwu4dRPU16+xIcfaEaaHCM5VcDmWMW5kQs0RYu4rWPEsmFStTWY9vXMzeVQ9DIRqc669mX2DlbYNxDi+Lkk7nW3U1cUykIz6RqY4jQe6zJhUSW9PIMou1goOTi/YsUZbEWUbGihAHlNRFIrRIvnaatcZEe0RmPqCLduaMWbfo1e2yR9oSRN0RRP/+DLeOwaUV+AjWvbiC28SHDxWXYM2RCNGQR9gbW9NbZuKHD/5j7aXTW29WTpdB1mw5pmykWDX/3lPm7Z6ebL/9fXEFwfZKLQycFJkRePL2ANbKZiNqPKPuqigiDeuGTqpxXhXx1zozrTNyiw/Hs+/I1wV9P4t4j0ag3r1XrWq9fdKEn0Vp0CeKfN98xr8FOYOvqL1Zm+JyLTmgqFWpXTIwfImwHUigOjLhMKmhTzY3z+Mw9iszXw4x8fIJmuYDqcr3/Ab/kQEa/gNcaVbypZspAt53BbFQTAZrHisjkp1uo4KCIIBppgpVSr4PO7yWaXyKtd3HlvhO8/NcezP/HyZCVFyJPFmllkuL+HdKmK3eZk2+5tXB4/wNC6uzlwdIJ0aoqpS+M0uSOoLplzB/fz8gkf3g0PMisWcZcWqBhlrGaC2bGTpHMVgi4Z0ShTD0rU1ACypZGqkUM2RSTNTj5Xw1op8dorr2EtrDB2aRGnZx2xlRwVQ2XfUB/15CJa5TkarD4KFgO9ovHsM4ukknF6uzdRXBbwiDHWtTrZvecjfPvvXuWeO+/j1LM/4HOf/F2ysQtsW9PAxXojixkNyaxQx4a1vMDN6zx876++wK/tvJmLtkXarVY2dZYp9i0zWhfw9A0ymq9RM9KUKhJ2ezsVweD4yCynp7/DxXYR07cWuy9KbGWWuekZ1qweZiWeYmGxhtUl09oTZeTEDOfPXWLz2i0sz8cwalXG5uLU1AShJoHmVgNRSJIpNpJYiGOKdZraI1TqJoLpYGnyGDf1C2xa7SSff4ENm2Sy3c3Ex75FMtuPx9/CeLbAhrs/hlNZ5pHvnGSh4sbe0spyapHN/V2sTL9GYzZBv7hCWCkTX1jB5fUg+2RGlizoahMyRXYNi7RY87hWBDJbt/GPP3geh97KkusWUstpAnWJFDYcNoUhb4Y/euhmjHgJPfEKlUKS8WPP090dxG3XkG0SjoCdhjtv5cjh85hLr/CBTe1432+l1zNIuRJHs0cZcjVj8TkhGmL0le/R0hFG0KrMnJnEdFtZtzXE2Ks/ZP9iAt1u5fe/sIuFBDz6ZJpL9kamyzJCIEjdMBHN+tvC9m7kjH6Ws72R3SiivJ6jvCre8k7mfC/Ye+Ju6prJ8MZNWFwilVoKWbbglIOYdTsOa4AnH32aU8fOk1up43c2XfefeT22hiRJSN5GVlSRimijoivIdi+GYMOqg6xLSLoVjz2E1x1hbnqJsekKTz/zDzQF3JTzq6iylY5tHyO+UmFsYp6fPPM8VU2npJZR6yXGxsZoa+sgkVxk/yuP43doRFx2tqxbh2bxUbS3MZuVCUdbCHe58QWhUslQzOtYhAgBsZFSsYxuOKnVrIimgqTLWDQrqCJuq5NLZy8xPjJJW9MqZClAY7QPQ3czcmYJKzJCdR6zPMaOjW3oWoVcXiUUamXfHQ9w8tQcxfQ8Wn6MH3/7qwwPDvHEUy8haxnKyUlGT77M8uwImcQCulbGKglIkkCj34GRX2LX5jUceOYl+nsb+MQn76RWHOW+W3vQ0imcNhNRSqEJc+hiCtGqUzU0qqaV1rYG0rkENUHh4OnjzC+PMzc7T2wpSWt7L9NTCYYGd4DppbiiEXQ3oFcN9GqdiN8PEQetw12ULRqpQp5V6/ZhCW5kzeZtrNqwCU9LK3lNZyGVZmx6mjXtIbq7Qwy02xELU3RFLcyPn+KJ186hBxo4OrXIn33zWZ4+WiG86nN0b/1NLE0DvO/DD3D2/DE6ozb+y0d20Bso4ZRSNLU18IlP/BKLkyNkii6KRQ9WwUs1PkNq9BAbggbVfJy773kfVcVLydZOSmghJ3eSlTdTrgepZuJ43FniuTMkhQmSeFEae0jiZL4mk3cGKOY0ZCVIe8cQw6sHwMzTu8pPWZ3i2RMvUrF6eO3EBCOvTfP4Xz+FMwCaNIvdrdPSeAvTcw6ePXiEpXkXC7EWdt91N8nEtzjx/G/iXfoRDWaC/jVBCkqRoqVOTX57e/y3Q+d8J3a1xvWtdZ3Xm9M0zTcw0J+Gg76beO27Ye+Jbf5Xv/KVL/7zn/4lI0cPcc/H13Py1Mt4cTBjcaCqYUzDT6aoghKgbATQLSVUQUQ1r/BxJbOOpNsAEUMwMWUD06gjmSIyMsnFGVoaAxSLOSTFgWbaKFsMDEPGkCVEltkzCGLyLLPmEOXaZtYPayTGTqBVLZyfXaBdEHB6S2SzKS6PLrJz814W5qpMp4r42tpZLsLw8Hb8Xjt1bYVjJ58nI36cRc9dSB4Nb22WiMNCbtIk4G4lZRYZWaoge7exKLhRrQ1okoRAFQs6imlQUtz4OYsvP4odAVtrhNHFPN19O0jFS0TdcUL2MX75c5/BsLTwyKPHwPTiDyisGepk/8s/wRdppGIa5KsVdDNDU8CNV/CybsBCqZrhwpmTzE0mqGZL2LUUgn8jNSTWe6fZ1e/niYOLlHx76esd4sf/8A+kEnDodJ1VQzl87i2I5Tq+9Dxf/rUPsLrRzakLUzR5n6DZW6WwUsTv8vHQhzazOPEUElkMs05XTx+xZIrJ2XEWlqaRJSdup8Tk5Cgf/fhDHD83SaVUpV5MopdLHH7pIpLsJdTh4OLxI6STcyTiMyiyn5WUSGN0BxfjFQbWdmFvbMbtMCjlVILKDo6Nw7rdd/PSkSzZahdLZQH3YB/nLiY5f/4yy6Mj3LO1jQ7rfkTHHNNLTjyefYyev0Q4ZOPw/iUG+1pJlrLUrR52bt3HYtLgS9/7EedqW5k4c4B2nwpaBl3yoLg7aJUv8YHtK9hqRV55cQlZFGiKLvP0k0kMSw+arRvD1sD67RuwOAKMXpjC7/RSriyzsHgKv7eKIyzR3hAi5HbitTmp50us9rdRKdRoHmxlMiXyLy85uDBhoVYq0j/cQen/4+69wyS7zzrfz0mVQ1dXdVfnnGd6cp7RjGRpFG1JtmwZY2RjsxgMlwd2YZeL4QHD7mIMCxize31tsIWDbDlIVrCCJc1ImpxDd0/nHKurunKuk+4f3TPqUbBkzB9w33nep6p+dX7nd+rpOd/z/t7wfbMi+bjE6MUBOqpruW6yxpYAACAASURBVHVPG23t3Rx5ZZAK/xa81gCCoXI9IP5mftD18m418YZhrLYRuqnoX8A03z6ZXhDNG9t/QVirn0dZazu8/hQCgiiudnZYV91kGMYqsIoChmmuEmKLwo122Bomhq4jidJapziBd3psmGIJBH010L023wSmfsFt/r8LMP27v//q5++4516GZ0c4dj7FPXf8GonQFFIyhEV2kLcLpOQIqpREkOKYhgXE1XI2iyxhFQxMY42FXDBXnagGSIhkciVaWxsJh+YoLy8nGkuiGyKiRUIyVxt3uZ0Cu1sEjPAVhoo1ZHN7WIle4JFfPsjIyDQ2m5/5XI6So4psqRJBrOLAvl6SkVlGQx7C5nYKrlsRSgJeI0JDexXfePQ8i3IAua2XREyl0pwhGesjlzdJYWcoV0HUsQ1b8ABx2slaKkkioUoudNOFKflwajNUaoOUaxEUw6SmNsi1dBXxoo+8LtNWK+OSljl37iKTQwPs7t2NViySzUYYGRkGw0W2FGDDll2EoymKqkl0JU0gWE190MHTL5xAzRewShq/9XufZcO2Lk73p9FtlVjlEk/85DWyZbtYMj1cHuujsaOVyNI0Pe0VvO9AK8mVQZpq8uxsy/DlP/sAVd4QkeQAiqMCI3mRgF8nmU9R39iAw2rhwKEDLM7FKSur59q1MTDh4Q9/hOaGJsaG+2loqGc5FGF6Lsx8JILVKeL0uFANmYIKOS1BKWqSzeWQrVaKRZNyfxUtTV1Ek1ZiS/NUukWee/YbZNIZ5uZCdG68C7vDwdBIjEjchsXuY3JuBZ+U4KFDXtp9KXx2jSdfOo5OIxW1IpMTR4kurBBeLFLbBDs2LzE4EsKQ3YwO/BN7N7rZ3347sdwKd3douBNXsBfnkUohNtaJ+BeeYn/9LM3eAhuaW0gtDKJkQijOLjb07uJa3zUO7d3B41/7R8rcGrHQHJVlDprrAxikmF+YINjgwVIRIBmNUMgXiaxEWImsUJIcHDl5lm07PkBX663s2RYkvPAs5fI8spamvWnVz3pgdzfOxhoUzSDQtJWa7t2cuXiFQqGEuLaF/tdsk2+mBnxr2ekb391MAo1grvOlvlE///a9m7gpinXdb7raOE+8aZ0bIghIgngjbUtgleH/ba1XYc2vi7jKdrI24xfNM/13sc1XrDYGZ16mY6MDp+jj8rHz+O0heoTTBOV5EAV0uQpNCKKpfmQBBF3FIoKaz1As5FaJidEQTWOtDYKILkhYHG6WwjHyhSIWWaKUz2GqRSRBREZAEkWsioWA3094eZmkqoGzlZTQwNMvPc3v//4jlClpCsFNjJZ2sSR+gKh8gPPDYTo7neC0IlduIsYm5mMKe+45hNtM0Vh9C48+9kVIvEaHzUZDhYcPHN5NKTeByyMSSSoonl7mUgp2049cXCZgS+BFw2uRMEsxnLY8yzPXyCuVxG0d/Pin/aRwMhXNgKuS/rEQGbWMUNiOpFooZHPMTg+jaRmWlyPceut9jM4mefa546STOqJgJ5bJMbkYIl1yky55yJRknC4ZvTTD4KXvU6YkScdiDCcCZOvuIu3tJOOso7zjHpZLTVi8DeQzMfxY2LFrHxZR5OKJV9nX24ZDLPCpX/kw83MRduzqQRMW6NlUgctto7tzO6Ym0tLcycjQGFs2bGVz12bOHjvHq6++SlVVFdt37CCRSJDP59mybS9Y3Jy6NEQybyIoFsaHB3DY3AT9Ndx+8HY+858+TXdnEx2dFdhlOxfODPD6kYvouoLFIeD0G8TDr6GlrlDvm6K9bo6GyiRlikAuk2f4/DPceUsXJ84NMqM8QMJykFQpz8Ofuo0HHvoE/RMlXN4EhKa5pW0D5aLJto1eRoZfQS8aaLLKxHgfbmuR23dU0+FdoF66zO6aBJ3eBDVlYaanT2JzluPxHqZpk5vB0efY0qtw4pWvs607iN+qs7W7jvHxcwxNnKehMUg2niSd1inGM9g8HqL5KDtu3U7BlqG2uZVtm+7hlWfOcfrI93Aa5/jwHS7uOVhGmXQZjzJIfU2RdHISVpbw1roJLw3yxA+/idup4POUvWNp5XuR63Pf3Nnz7QB0farTTcD6r5Drbrv167xZfhbXwM0q39BVCLyuv5j8u7BMv/hXf/n5P/id29jcW8vJE314rUV8ljkqbAvoSoDJiIbdGcQpV6FoQUwhginKqKqKLBjY5FWrXTeNVcYcUV6l3ULCkBQUGRwWk+nJCQqFEp1dG8kUC6CvPi1T8UU2VOXwmwucjweJZ7ciWBexqHFE3cLMwgDLeiWSowHdKMciCrQE8zT5xjnZH0W3NRNJ6zS4Z6njLI5ckt0Hf5U//cd/4DO/8VtcfOEIeuQMSilEMjyPgQXTuRlBqUQ20tRbU3jtc5Q7ZPSkjNXQaGvxAllqrcssRLLozhpi0QUCnftwehopFg2cQpSH7zvA4OgSQimNiY0duzayELpGU3MdC7Mx/HUb0NUcoqkjAlu2bSObz7Nnazenr0xy770PoKs5wokU3po68vbtzMcc5EQbhiQiiyWkYp5UaJliIoaRHGNLsxM9Gedfnh+kqqoVqwnLC1HyQj0j6RqM4gqJ2ef5yIO3UFvfwhM/eJarZ09TVe9ncSHG1PgSmUSWeGyF6MoysWScYjZBc1MT8/NL9A9OkMzqKApU11TT0dmLy26nutJKJprFapPo2dSF4nbj8/pwl/tpbN5CMrLABx+4nfHxU2zfs5Wuns00NPsppJdR1UV0EthtAnarjWw+T1NZgp8+/zoFuZW09xBzY1f4vx7Zwovf/QcURy9S5W50eQVjpZrppTLCiQR2yzwVgRpeOxMnHehENnSCjV0cuzJMXWMNQY+A3cwSi81S27mZrFxJZXUrddVtxAtn2LG5jdb2GuoCFoYGz9G7vZfZiWGCtQGSmSiKRaHc5yeni/jKgwiCTE11HUvzIfSSjp5XGB5dvYbWBj+15Xnc1gwTA2PsuP1+yt12+vrOk1jJ4BAD/PM3n+HSPKieDvKmnaIqYQpvRMrfzFz/brJ+qy+uywpYb7Hquv42XQSuW4Cs0eKtMgW+E82pJL5B37fez2ryRhT/5qomEdMwVmk+1qxa823q8AVBwFhbez3l36pl+uh//G3+N7/+xc//lw/78AYL9LTFaa5MYM3MU9dWh6mDUIpjkXJIep5UOots1REASYBiPoPPZUdQDURFRpAVNCQMY9U3k1dNLDIIRpHKcg+nTp3B7/MjWO3IOiBIuF0iD+yv4fSzXyVi20tSdlKS8sjpesJLUQ4/6GT0UopoXiddkLFbFSocOSqMa1y6NIOgmfitOf7g13bz3ONfIGBrZjhX4txckOGBGf7+r3+Tob6zpDJ2Dt26m1RRYqVYB5KE371MhfYSdmWUQkwiWL4PySKQM0YxQ0PUla6gKk4kbwVN/hzJkhNVtVLIl2ipthFwWbA4WykLVBLLFHD5DB780A6qq10MXOpDdJUT8Cocf+U5ylwOorEkVruDTHKSWMnNhStzJJIqmhxgLFRgwWjAlOsIp7NUVgiUJY6ztzqMMx/ivn1dhGZe5P57WqnwOLFUNCEYaRJLY1RX1HDk/DRzYhePvL+JDx5qJDw1QikjEV1c4v7D2ylIKlcvD2IRHCzOztHb08nM1Aht3d3k0jFi0Sj79x9kdGKe++76JdKZJOPjEwS8VVw4/jpGeo6qah+BoJMnnvgB01PTbNy4kVg0zAtHn+UDd9/G177yvyiUlsnl87Rv2oNkrlBZ5qDKHeHalZ9QXSZT5apg71aT1NxJert2YAplzIbT1DRYYLafOks5/+eJC0R8O1lJBplbsKG643z6E9sY748xtdzAmH0riVIZKaGGyUItCaWG7Hw/Xe4M/dNLVPrbKA92MrG0SGhhgk1bOqnwZSnGIpx6+XkqK8ro3bkHMxnFU+FGdkqosoFsdVDmqSIekjh29Bwb9h3ime89ictahpY3MdIpHE4nmze3YZpLhGcn8PvbOX1uhY6eg0RjCTZt3oZFrMQslnN01sqxySL2hp0URTc6EpLw9sz770WuA9hqWepbwfS6rGeaWv0M18FUEKQbm3FJegff7LpzrbdsWdcz6i319mulstfbkmjrOgzIsrwO8CWuc6iuUr2u/ps8943/+Nt8i5jFI4dh+QLBshN0tk7S0yDz7JEzbOtt5OE7a/jMwzVUBwZAOX5jnmEYWK1WUqkUTpcdWRLQtRKw2q3QQMBmc6AbYLVaUVWVmqoglYHADbZtATA1HUPXCYVCyLoF0boIVhmbcw+ZrJfJpXPc0llDmSWPw6GjGip916YIeHuRcwaRwXPUSYsMnfwpc1MhbNU7KQbdpKzbWE4H+dxff46cs4oFrY2nToxxdmSJvGnF6bGSyc8jSH2opXFM3WAlDsPTYZx1AebOP0eTJcotG6uwFJcIyBEcgkohtUJd0M/M1CzHTl7i9IVRLoysIHnrqGxqYDk+R5lf5s47drKyMsbItbPcfmgX1YEy6qsreeiDDxKocJPOF3D4Gujd+X6uTWRo33QXiZxGPp/H73XikvN89qEtNPAav3ybi/jkM3S1l8iq1xDsCcTCSSaufZe7bw2Sy/Tz8MP72bSjhW8/+mXCc3OMXBkjNBPhtgN7uNb3OmfOnsTjdXLo1v1UVpShazn279tNJpOhUCjg9XoZHx9HVVUe+8a3mByZYmPPZtwOL5u7NtJaW0ddowevT6altYat23r57mPfJFAVoKw8TyozT6DCzUMfepjlcJzZsWmOvXaekYsD6IkQH7unl/tv6ebObZ0c2h3Fo1+lt0Fga6POZz8UJFgrMNk/Ty7spnXDHjKuSkYiray4XJR1Jhgc/wZ1gU2sxLpI+vYgGi6yYiMrYgcFezfdHZvxljJcHRxlY88hXJZKNjRVsXNDgPjwi8yNrJBcLtBY1c6VixMglCO4nFi8HqaX5ogXsswvR5hZXEEseWkIdjN5ZoS73/cgelGkNtiImlmho6mCawPHeP3Yk2TSBQaOz1HTcidf+ocf8fgTr/LMsyeobtnG+TMjxIwq2rfcQVF0UhIVzHVN/f41YPqzttnX5d2o9n7eTIH14++WR7p+O3+9NYzFYrlBVL16PumG3rzl/8XkXcFUEIR6QRBeFQRhSBCEa4Ig/O7aeLkgCC8LgjC29upbGxcEQfiyIAjjgiD0CYKw7d3W0A0Dw1Jg8NokanQzqr6R7546Tl47wJMvlLg8OoxYfJRPH+zjsV+XqJaySFIQi2xFVtMEAg0UxQUq3Bm8ZhSLaaIrCoacwqom0CWFlGDDapVAzZAuagiGlbwjS15yIuhpZGGCyqrtiIKMVOjGNATieh8ZycGrJzdwYG8VnlSGoiRSLLcjlaxgsyM4ini987yvN0d0dhhb48dYyIY48+RVOsuz2GvLKbruZ3DYTj6dwSl3Ycu68aUGaQ0G0S23EZY+S1x9iISrmiXnHM5qF7NnSvz5n32Cc8s2fP42mgNTGPlFKsxT1EknsCaP0t3dicNdRq17ku7Kelx6joBVwmttRJFbyOBiV7AGb0MdF5czxPIBkpE4Dvsyj78wyXLwowhN+3j1hW/x337rk0xPFOmu20KgGu67bQs95VUMXhrjQw8/TEDoJ2Ac49aWFhx6PZPxcTo6fNx5sIvp8T5SmShyaZbK+ccglMOi7mdj+yfxOd28dPQMVb2f4aFf+h+8/2Ofxl9h4vJq5IoFJqbSlHl81Da2sLQYYml6EUfepLIhycd+6QClZAg1n6C5twqhXmVpeh61oPL+3/lNELOo2gqTA69x7x02gv4h7r2riVI2xi237KSmWaK6rpKachvnT8UpWvczGZ1laP5PWLo8gs3jItCS58BhB7vai+xTT6IKI1w2iiwYXQhLIZqkx1Am/4mu5BTutMSF2DQJfw5nbgabPYduLaGZK0RGX2J3TzWRZIpt1XXENTepQgYp1cfy3EUGVhKMTI1wdkni/HQRXXAyPTlMrBRhZnKKSns1u1v3s6V1M5XBclRljq6ecpYmL5OYnkKLpkjMx7CWPFwYmMLuDXLvoTtpqKmGMomTY0uEq3+PRMefULX3Iyxm7cSVTUTK7ibv7kAVTASyCHL6ZgB4DzyjkvGGirqJqJsoiDelO72dT/SmVCjDDqYVTCsCq+Aly/JN1IA3uR2uM+ELrDHGrbVsXrvm9Sz+oigimwKyuNqNVcdE442Gg5qm3chAgNUOBBgmggmGpoNhIv6cRCxvJ+/FMtWA3zdNsxvYA/y2IAg9wP8NHDFNsx04svYZ4B6gfU0/A3zl3RaQJYlsUaZ5w07kcheSuMB//sO72bNpGTk/RXIyTyGmUcxNcXHg7xCkeQr5KJIJNotMvrCCma3A5WnH4alDNDWsuoGoeVbjhqYApoKuSWi6gMmq41lY868IpoGJSkEtIFFCREXAQDVFTKsLyRngav8U9f4wPj1BPqyyYoiYRQtT42PU1ZVj98DFwTFwdmH11VMyFe7cvxWXGqKyzIa1ppuEVsPI7DKmUkDXJrl1RyUBOcxgup5ZYyMrZhfpoo9SRsNvMfju1/+ZA/d+ktf7lzGdlYSjUXqr7dy1o4ZG3wpm5jxBZxIPBU5evUq8mCSnJVCsCiJeRq6VsAcPcm0qR7C+kYZGB5t6Gvibv/giPrtKcm6a4SvTfPLX/5ixhTQTczMMTV+ksDLI1PlXGL5ymkjB4G8/9+eMTw3j8ZuYUghBSFMqFllZmWBo5Dy9ezv5xK/dz+T0aWZnT3HbrXfxx3/6BV46epbqug3UNm6kzNeAasj85Z/9D5IZlXhGY2YpTjyjMjQ6gqQolDQVzTQQFJlMOkd1Uw1VdQqycwpVmKSru5Wenl20dG7l9e/8CF95AH/AR0tHCyePXOHM8X6ioRQT41M0NNQgu2UyahF3ZZC21o3Mj6Z47dlr9B+Pcex0Hzv338XYVIjXXjtGaGmMGoeX7tZObA47c5Fxdu7y8rH7g/zDN7/A0tICm/Z+lGipDkMJIpo5VEPCNDTQi+zesZlQeIGCUaJ5y90Mzqzww2eeZGl5Ba+rmmTUwqy4mYmcn6zixlru5uyFl5gansJjcxL0+VETGU4cOcH4tUksdpml8AytbXVEk/Nkcssks4tEBROvvxKPxUV0fgVBsTGVitO0+3aGVgQuzbn46nPzDBZrmXHUoAtrTefW+RLfEQzeAVjX969fr+8mN1ub5g0VRW7oe7F0fx55sxV7PaXqJstWNG+oJAuIErxDUdjPJe/6C0zTXDJN89La+zQwBNQCDwDfXDvsm8CDa+8fAL5lrsoZoEwQhOqftYZWKqBY/SRKfk6ej3Dp5CjMRtnR8wy37Xmd+++wsjwUZehkkaWBSmrK4liLYWylPLft2ER2aRRyRaZmQ6TUPA5hlgptDIcZRzJLCJgIpoyqi6i6iCGKaGu/XDINBKOEKWmoZg4BHQkVER1JtlLAznJe5si5KX77E9tpFCJUy3ZKioW/+NxfUFvho//KVTzlEtMrWS7PSqhKAH9dMz994qtUZK9w365a0koZKcsWarp3YStTmB0/Ta2zD3fmFZocEbyKRMH0gdWFzanhtM6xPLfA8VmZ/Q//IRVtu5FcfhC7CEUlspqFTFEjnDDYu/+XEey9tHYcpL6xAVkxUAI+PL4anutzYngPMB1R6b92hJ3bmjBzOp/7L4/wmx88xEfue4izownCRTvllRXY1QE2Shcpn3uCL372Tjb0dvHQxz9JRWMl9a1eFsKXWAkN01Jdg2w42Lp5H4VUiXQqhUSRnRtque3WLj76yH2YDg1HpYuNuzZQXuXm0Ue/hdPl44WfHqWhpZtwLE/esNDU1kpHTxfpUoFIMo4ugMfZRDqsomk6dk+Mxu5ylmY1rvSHiIR1ItES58/1UREIcv7kcXIxB1rGzfREAhE36UwJTJHZBcBRQTS1Qig8xYMP3smGjhZu332Ia+eHOXPkBHODl0hMvsrC+IvYLUvktXlcAYV0KkIxuszl575LASdf+NpJFost5KRqTCGLIVuQBbAKBvF4lL7JMGG9jO+eTPLs2Rm27r8dv78Wt7OW2YkCx5d2czncTEZs4epoGEl2kAwlUQyJE0dfY3l6jqA3SLm9BotcTTwugOils2sbouTERKEopinEw5SWQuSml5ifmWdwYoanXznPSkGmZO0iZdnP4yfjXMjJYFkL1BogvQuYvpOlud5KvMlifBe5KYIuCTfUMPUb+mbf6i8qbwbT64n/N7sIVl2soihgs1mRZQnD+MVJUn6ux4EgCE3AVuAsEDRNcwlWAReoXDusFphbN21+bezN5/qMIAgXBEG4EEnoKBYnCxMx+k4usefW3+XYizHs2bu5cukIs+GvsP9WkV27Arzv0BYaLLPcv1emxXWVjYEZWp1LtFSuUFMn09gSpN4eI5A/ipsTmGYcRSyi6yo2m4Oqmip0UcUQRUQEZEwkXcMwi9h8NtKGiAZg6Ji6gYCCzRHAKO/m7778bW7b24JVG6TKmmLP3g24HAJtjU7G+oboaO+hqr6JXHyBmdAciGk+cVc9ueEnKZdDWILNaLKPw3d9iGo/pOZf5cOHnfzqxn7u7swg55ewyxmM4iiPPNSKu6mb6ZKfHz71GpOji0ytwNMjTQxrdxBxf4RZ4wBjqSa+/sxlBFVnaWaR9GKemdF5/uX/fAXBbSJWd4NzK3bXZtLZDN///r9QW9/Mcz/5EU9+/U+YnX2NmJnn+ddep5BOIy6PEzSucHi7iRo9w7XL/Zzvv8JKMo1mKHS2bKKjpR2hlCIfreDc6yH+6auvkEnZqPQ2UVtWwdT4s2jaGJ/+zH1MLFygqM7zyivfxuuA1sYKNC1DS2s9NqcFQTJZSSd4/sjLhCJhgnU1TC7MEqxs4PvfOYZV6KAm2IOZU7h2OUsoVuA7jz+F1e7HavUxMRYi4KtDlMtIZkUWllSGJ3MsrLjIFmrIFqqhZCOcXWEhM8Orl44wk5pncmSWbNJGQ3ATVsNOrcNkLjlM15Yg971/D7u372V8tpyo+BCjmXYs1beQUZ1YbS40EwyLHR19tbjcEEjkHfRH/MzZbyFTvZ2y7rv4zo/O0NjUg7fMwfsf3IcXNwFHOa0N7fg81dTVbMI0ZCYmpmhvb0dRFNpbN7K0kGFsOEs+46OqdT+jIxFsjiosFj/NwSpq6xrJ6BZCBQcnr8T4z3/4T/h9XTQ3B3DaDCSxjEzBjlIeRBVBFiUspoBiCgjmGylE67fY65vrrd3Tb9TMiwKmJGKIArrADX1zGtR1K/DtU6C0GyoI+g1d34b6egvsN3dkXYcZN67tzZVU6+de/x2qqqIoCpIkrTXvWyNDQUUQdUxUdKOIIOpYrL+4ZfyezyAIggt4Avg90zRTP+vQtxl7yzPRNM2vmaa5wzTNHYGAm4nROaYunUTOjvKtr/wxrjYHoZRGDonaxi5yOZ1ofAbZOUmPb5jE1H/HbX6ZhcHfZ1v9II3+NGaxQDYGVYKHz35gH3s3ilQGFEwjg2CW0CliiCVMRcVc++miARgaTreNsakhspIDVbQgYiCbOrJpoJgGK6YP1XqAC30n+E+f6iRYmOCuD2yjvaUaRRWZuTZLd2MDorGI24hgc4p87DO/QlOwwLbqOJs9CyQKy0iKj+UFHb/dT3N3NS2NWbx1QX5y7CJ5tRw9XmCDW6J45RnM2jaSppNSPE2ZKIOtiZi7icFkOcORCtJmM1ityK4V7rsny+17bBz/yQu0Bg/gsvQSiZcztjKJzd2KqtbzB//1iwzPzGD1eVlcjnHolhpSmWMkShP4gy4+dOfd2B2dTOUyZCsVTsxNMp104qlwIMhuXn11hEtnwzz5+IucO3mEuakwpm6nd9NOEvEUiqQzOXKZqb4L1FX6Cc0v0LF9L3NTs4xcHcBGEq+txC9/+E5MLUYhF8LlMMgWC5iigMfvY3pulur6OhpaBbK5JEMDc0yORfja136I01HObYfvoKDpOJxeRkbnkQQ3Vy9MEi+kSRUN5qN5ZpZlujY9xMkLBeobGrg6PEI4LWGvuIWplU7S5j2I9fu4ulJJRNqK6tlD1Khlx+E/JldqZHEyxcWTl4kJjTw5Xsa3T/s5OSLjdSmIhSkUIUvO9CCLKrIIgmilINaTch3gYmwDYcVDuBQgUL2bU6cvsBDqR7RPsMlxgkPty2RDr2IxQ+x5/2FuvfNukC1cvTaAYFUoaCbl/joO3XEbZ86dBPJYHSZb79hFz+Y6rK5eSrX7+N64RrTnYQotv8rv/PUV5rJ1hLQCGUuSvGIjJ/qIlspu7MBkQUQWxJusNU3T3nxPviWfUxCEd7RM3ymP8+1RwXh7fQ+y3vVw/fN1f+ub17yelvXmnNfrjFSSJGGzWbBY5LVMAhPT1NH1n81E956u870cJAiCwiqQPmaa5pNrw8vXt+9rr+G18Xmgft30OmDxZ52/WNJ5+aev4LEL3H/vLhxlWZp6y6hsj1Hd7CAUVjFK9XR0HyaTlBC1eTqaVO65sx6XfRqjOIpDhoW5JeanYyxNRrjw+gkWpkdJpqI4nVYkWcA0dQx0BFG/yecjS6tPsWAwiGJ3YUry6hPWBNE0EEyTZF6lqPlJ5hJcvXqU+w7twNMYxOt1gyGRiuYILcxTysfwOkUcbidFQyMamkFNL+KVM7i9Fnbt2oMiu6gKNnL12KtkcitcnUthrezEHWhDKIn4LVYWrlwAuwfZZkPBIBZaRseG7LAg2+wYpojVasdm1enocNPTA76yDLpa4G//6qs012/HaqvH47ORTORwOSp46eXj2B0uFkJLXBkYoqmxgjI/pHJhdu/ZTimdpqJ2A7IvSMPmrZwdncQeaMbmsiKIMmWeamTBh5rXcNit2O1Wtmzt5cSJY/gDXqamR6mtLkcRrHjsZSiCjaWBUXZs3sv7Dt6FWkyxZUsPy6E5FuZnqK6qQJFX02wURaG1o53mtlZsNhsT05dZWJzEMAwKosF5vAAAIABJREFUhSIPPniImtoK5hfn+KPP/xkNzc0cPHgrxaKOItvx+rz4g5X80Zf+N4GKOmYX0iws5VhanmYlGuX+Bz7G7JyBr2wnuVwLcqAZe2UnV6ZTDM5lcQY7ECwdjI2l8diDyIKFiYUQ4/E8Fv9mSngo5VP43CJOp0zJEN9gHELCEJ0UBB+iuxmrx8vsYpRsViCVyhCLLxOKjHBws5egJ4nTmuKeu/cQnRxGcrjYsHEjVruNqwP9DI2MIVttTEwMsGNXL/n4Ehabzos//BeUpkqGxlf43vOnKZY3M6O5yTmaiamVpAwPostDQs1RQEQVHaiC88b/ccNYDbqIoojFYrkBRm9zr7/npne/SFbAzyNvPvfPusY396e6frzdbsdisWCz2VAU5UZTwOtz/i16Qb2XaL4AfB0YMk3z79Z99QzwybX3nwSeXjf+ibWo/h4ged0d8E6iaT40ZQuRvMLIZJje9n1MXJph9GoaLeGgq76RhbkJnnvyOJJ4gJTupaIgsHBiDrfexF0Pvo8DXTOUS+dQGWXE7uNofidDyw8h0ks+78fQJFwWGxRF1LQDv5Yho9SSsZbhlcLY8jp5/SDoHlz6JPaSD02RwJrHpvrwyxaWXeVEXbczFmrk+IVXKIwU6O3cQE6EiykvKbmNOjPOVKKayKyNL/31j4g46nh9bJjD291stlxgcniYmYKDYUOndesOfHILO3rKKKXz2PPzdPhG6e0xeXnoPN5cDc2hUzR5XiJQnqKUHKeEA1VcpiSNI0oqZf4WltMJnn7sWV5+5iXuu+t9HDy4gxdfepprAxeYiVXR4JfYXAczQ8NIgpdiKoPH7uY73/vfpGeG2edv5+LzT+IOTKLqEhHLJ/lfXzqNM9lCKTROPD3L7n2bcPkcXI3HWXE2Y7fvJLN8nGzkFL/1qTsYHjhH78YdJLNeWjv3YFhKVDR5mJkfY2apH9M2zYH93WSyWRaiGhX1XQgWCyUhhU2ykM9l8Pk8tLQ3EE2FycWrMMwiij2NLFTidtbQfmuJsdhLjM+9zPDYOc6fP09RNWjs2UQuLlBQSyQmTrFrU5AzVyP8ZKARu2cDyalzvPTicWr3/BFHJp007tjAcP8IFwZVcukayjydfOfp1/n2RSuvhNu5kqvgQ/d4+fUNT/KrFf/MTt813C4HrppuWsuWqMqeJIgFoSijqQKGATYlh10fx6tfpi2xgKfazYy7A0/Hp1HFLWglK81dSfLTj3Pn1jaunLiEw0wzMvwScmU5h37p0xz+5MPsvr2BkYFnuPT6k4wOTfPcjy6TGisixixMXZhFNmZp2/YbBCo+Tq/Txq7AKR65P0WzfwDr0hXKcyAaJlbylGthRF1ERaQoyxQlCUNfNRyuA9L6DqOmaWAY+ltVWiVjE0URWZSwK3YkbTVwo6GholEQVzUvamiS8RY1DWGtYn7tZNf1nXHnLXrdFQE3+3cNw0BDxDBBkgQkQQc9j0WQEQ0dl13C7ZCwSiCb4o3MgevsVLIs/5s8BN5LctV+4BGgXxCEK2tjnwP+CviBIAi/BswCH1n77nngXmAcyAGfercFdAMC1du5985beP6pV3Cm6smrFbzvob1cfPZb/OTZ0yTjBQzNwdzsD5GEEdqbqnG4/MyECvgj9bjtBs7Ua/zaLRtw2EwUbxVfeWoCjByaFsSi1GFoeXRVxiJn0XEgoiGZOoqokSvkUaw2VE1Akq2YhrRaISEAGOiyhGk6iKYKUPSys+ODzK68Rl21lypfI2Gxm7SznsaWFPU+Fb9dZ++Be3npte9gFhyc++ZJfMEqTDOCbBrU+GpILVtxVddgzszx4TsPc27oDLvr8/gVhda22xC8EUjO4k0cZ3tLC+MVGoOFMey2FiTdSkntI5SM4tcPkUklsVmLLObijC+fp665lqxpUJO5ipzSSOlJooV5Dt12J+mSk9evnqLZ5qdaV7Bkpqn3W7E6XbTVJphVfYj1e8hGfJjmCsPTPj7358/R0tpLyl5L0VT4cf8EvQ4Hht3FdHQJe4WdRDaC1WNnOZemo3YDUyOTXDrRR2d3E8HqSmr27IKSQTQ+xolj52lobCMSiRKsrOXK1Vn6z1+js62b9EoWucpJz4Y2DCFGNJFEYA/9RyfxOgLMjM6RSWbwlrnJpqMMjZ5naXYBT32QlcwES8kwI5EqJKkXq6xzMraJSH4XznmRupp2LFmNUvYqf/4HH2X62lXuuX0fx4+F+OcjOQy7nzODKvn0GK22NAcaBSRrCKPYRbnNgyj9gN59XTx/Ok6omKZodaLJTiiG6bXF+M0HtuMSl/ndx46RU7bx0mUVf6GB1nKRec8U2zdv4fy5c6QzBWx2C0tLy+RzZ9i0ZQ+qnmZlcYUde2/n0R/10bF5H8vTM3RYyigKSc4PLFO+69c5eTmGZEq0brfR5kxj2vppKogM6zv4wcAKCbMWRBOrIiOab1QhvZ1ct+JkWQbTsppapBk3Wa0iJQTDQFFkLLKC3WJFlcW1LbWBZhrIwirpiC6AhOUt64iiflOJ6bvJzwtuoigimmAa+hpJioShGZSVeXB7HKhqEUkWUEurPlpN095SRfWLyruCqWmaJ3h7PyjA7W9zvAn89s9zEaJQwOEp8u3vf5eAp5XuzZsZHj1OZmiOifEVaqo2MD56Eq/by7ad2ylzd5BML7KSNHB6WxkfLdDSJeFTx1H7vsZMLszVpJNg1QNILCDKvWR0D0VVxypbkUwNXRQBHYkiboe0mqZhsWEKVnQTQMJEwDQ1JFHBFEHQZUSlHN1Szuv9IbbdXc/Y6HmWpmextT5AWqnF65dZnDlNc/0WhgYGaQgGiKVj7NhzB+GhH3Hfh7azsBTj9ZcNnv3JGYJuE6OYYMQJFJI0d9Vz4sgoKet2ElojjnyK1mAXJg4sToWPb89x7tQxejZupyiH+PEPvkvvvr9k0dlExpzl6IXTFEqLVHo96IlpmuQp2ivamB4fx1+9lZODdSTUdubNAJsrDcTFl2mqz6AlkiwnLrNnyz5S55e5spBBEhqp8OvcefgP+elTzzEZFpkrVVC0WihXYEdZkWTJRVHTueWegzz65S+xcWMDqpZDURR+/PiPaGtpxOeowmn1M3h1lmwmRzKZ5fY77uE73/oegUCARHQUr9OHmi8xMTxJbVUtsiyzedMWnnr2+3z045/GNBRWlksY5OjoaKE+qDA5MYMoqSyEJqiqqKK5p5WT505TTLmQtSJyIcPWDb08fWyFJWUb7vAsjsQl9IBMT3MPQqKPxf7HidakmR1aRvbdQjgDVr0S5HJ0YQOLi1HCkpvF6CK79vTwwhNlzMwLpPVlejq7ODerYkgSpl5EyIYQYxP4GytoKrdwNpYj7PdQ5nVQKI6xNB3ByMfZv/su8jmVwZGrpDJZBD3OSH8/gqjy+vHzNNUcYFDdxvSkl+1d93J28Qwbt97HS+fPkzjpwhPw4LSEuHLtFTr21jJxrI+OQIL5pICeaEbwVoBgpaBLKPLbbOXX3c7XI90AIiKmaSBLys2BH62AxaogCSIWGWRJx+6WSad0dElYnScIN/JBjZx5w9q9AVTraDPXg+r60tD1gayfiRdrALie81QzjOtM0yCssvYbgoBikchkUlisIlarFdNYzdJZH3T7t2Ln/3dBDm1RdDBn0LUkKxGTl1+cxR/I8dSzp7jl4C0cOfpT/vSv/5FiNMvcbIjHvvP/snPXNvqvTRGsKmdDDzz+3W/R6TNxCYukhCQfeuhhLg9ZCTizLBhZLkyMIFjKEaQSssWFqosIGAhoeD1O4okYss2OqV//A4mrLFSAKRhIpraasypIRFNpvFYfr51/BfvyEPVVHoZliGcNspEM3Q01UGxiYnmazpY6XJ1uFhaW8YolvM4UYUuMYG0Qj+QhunSZcquLounAIuVpqKpicPwEdLazbDTjsUBEUumqrWX5pRf4jRadJtnGqbOPsetQD5e9VsLzZ6hrkEAX8Hsq2P/Abbzyyil0I05LlcieLRVMDpwC6wayaj1ZYwMV1Z1Mh05QUxLxFZZIZLLY41mWC8vUBOxMFyCZlgjNTjO3UE6uKOJyVWHEbeRLeepaqhgZeoFo3EkyNUtjfQ1eTyVz08uIcp6Xnnuafdt3EFlZJpdXqXb7cHsqsNvt9F3pIxqNUijkcDrtqBooFoNMKsPh2/azEiowNDTC1NQEpgmXLl5D1zV6N3VhseRQdZkXXz+GYVjZuHEj10YGSWcSeL3VJCID+GxWbHoSe3GK/ssLBCo3Ek7JHNrq5JaWPRz9xn9nbsSG7Iyzd3MPdknG6wugxuPUV3gxxVmqGlTExBlipRGWZu5Ecqf4yYuPsn3TfXiCHUxfPsPw+ASipQatkMEqibgrW3jt2gxjLw4Skb1s2tbLwsQlSouXuf+BWpJTWZaW5kgnkpR0A4/HfcNfnE9nkBWD5VCGTRvrad54EG9VkAvnX2BfswNDgIaWZqT8OQ5s+x2s4lbOHR3i1VPD9DQ4sVjt1FmrqZ22My9oaIITVXKxGkG/WdYDpdVqvQF4mgqYJiYG6/FFUazoagnFIoOxmh2gqUVkScQwBExRRDcNBHm17YWuvMGYL4oiqqpimG+w8a/fukuScsNKvA5qkiS9K6BeB+s3iyS9Qb5nsciAidvjRNeL6NoqBVKpVHoLV+q/hWX676I2/9Gv/s3n39dr4LS4eeRjn+CFp75CsDyGx99ANB6hp2cTDslNqSRSU92EbglimvUoUiXhpQjx8AC79m6ktDhAhRfEuiauzJawZ21s8cyQK2Z48dQx6ptqSSRzWD2tmKJAUTaxa7C3IYnDucLAuEhE6F61SAXhBpgKoohEHsXUyZV0rHYFoxjh4LZqBo4+Sn1Q4VLcTfeujxKMzyG4onzv6auUSiIt5Qsc3FvP8acfo8pTRjg1SjwTZWY+RVnASlWjRCxuZ1bZTWdjF4nxYa6FXUx47yGDB5xuyt1RfvzDL9NZa+X2WzagmwNs3enn2KujtHUd5u6P7cRMHmV0+CTFbJZr/aOElqIoNgEps4yazTC/OE5agZy7noxShkUpRy2u8Ad/9BAnzh2lzLuTC69bcLvLEOQkBZ+LmSWDDo/JxPRlzEKRCn8F6aLO5s31COkr3L7DRVdPDXc9cj//8o9fxOu0oBZy7NzWgU03kHWdeDLBjtsP8eRLzzM4OsPwyCiyJPL6q6+wZ89OpidHqGyoZXZxjH0Hd3HktaNUVFazHJrE768gncqRzRRJJBdp7y7DF3CxMDlBLqcRrGqks7OHeDzD7p1byJXKaazewtzANA1VZdTW2EhGJ5hPVKPmlvivH3eRn/8R976vkZ8eD1FX5+O2u3bzP//073G3NNDRVMHhjSLbyuapyZ9luu8pygMmO3vCtNQFcEkWAr440wv9JPUWUqIFELGJIAoaKwWVhZKNSfs+VEMivKLjdPqpcmhsq5MIj1/GrohIWFENg6pGN03NLSRWMggGyJJI79YDrMSdeCo3Mzxwhu4ajVbnPLu6y6gOyBzsnaNeEbhw7CgbD91FUrKCu5pjfYvk9FpKhTIyeSdFnORlDxYz/5b77Xrt+ptVsQgg6AiisZq6JBoIorFabmmaKLKEIhlgqghoYEgIIiiKDCJI4iqlnkU0EQUdTBWbTcbltGKi3LAor1uEq0GwVXtufRbBmwH3zbmj6/kBrothCgiYSOLqq91mxe6wUV5eRqGQRdc1VFVbJVkRQFGUdeWlq0A6cvLr//GJTv7mC3/2+f/2K4e5cjnCa1cMGtvb8diKLC/20dHzQZrqtxIKDTO6NM+S4mNhsZuLM3ncXoH6Bg+4JXY7IpgVCVIOnRrnPkpzDjYcaMJbVsBIjnL/4Z1MxGRGFjMEXBXkSjqGWI+9YGNLzTCyuczc7DYisgtRMNeUG38cUNBECUmTsWkmNinFFlngzInHqa4+xHg0TyGnUOZaoqxllqBq0CDmUa2znDj3MrIhsByboNrXSsBaTXIxwcJ8Fl/5FuobZMwFDa/UzwunEyh1HyHvdWHRqxG1AkGlH7veR1drjnTMRLT3cnEEJmNxbjvQxeKFqyjz03hsApH0NIpNxC25aXG18Uuf+jhf+vp3KAoKdf4mFFsLdz30SdSFc3jmUtxzuJLzfRpXr3ixW/3sP7iTxaUXuW1TgMLsCX7js7/FueN95ArjNDWV2L/RghIbpKPaQmHqUdRiFrskYypFdu3ajZ6ys6JlCIWGaGp209bewPRcmsnJAmm9SDYeRSxmkQwN0dSJRCJoag63u5GZuTlkWSC2FCetZti7/xDRSIy2thYMIUGwzkk0Os/KbA2tFbdTKA6yGLpKMimyMitjusK4PAW8ootSSSIvJrhyZgRPWxe//jsfQM5doe/sSaxSgNDCLMXcPA5XN0mhjtadh5HTP8YrJ3FJKRQpgs2mUFG+FTngIGXbyOWhUe7encVrGcbhtbAcq0ehHFmyURRyFAUXWbMBByI5q4V03oGUyGMTMvgbnEjCFEFHNXOpZaiUqWutJNw3gMXTzpGzo7hkESMeRis6iM6M01LRz7beeRCWicUWCXrh6NlRJEeMg3c0EE4WeO5UkLMzd3ChVMm1WA3hQhANN4IhoBgapmQgiCK6oa8ZByaSLKMZq1SVitWKYrVgAKouYHc6MQUwBBNBFlgN7bhQZAuyrCCtJb3LigVJllf9qIqM3WJBFgTQNEzFxGJXkC0SVrsFUVnlEC2WCsjKKmOUIlsQBIliMYdp6mtWpHFDV2vnb67H13UdwbRhmgKSKGGs+WwNQ0OWPAgCmKaOJBo4HFa8Xi+FQhHDEACZfL64CqDrylGv56AahvH/DzD9f/7xbz/fXZcjXdJI6Taqa/w01Xrp3byBxShcuXiOfdu28cpLl5mctDBj2cp8xEFXbQqSp0lP9VHuqcZbV/f/cfee0XHk55nvr3LoiEZ3IweCAAmCBDM5jENSk2c0GmmkUbCklaWV5ZUle4N9fMPa11p712vfle21j3ePr8Pasmxly5JmNNJETuAw5wgSIHIGutG5u/L9AIJDjkaS79V+GO//nDpdpw+qurrJeuoNz/s8xBpWMXY1h5erMDd3gUIly5njF5nJGFxfjPL6iausam+gqTOJJalEVIGe1HkkdY6hiRQZKfVjrlIgED08W0QWQBTyrI8XuXHlH1nV0s2Mo1DXuJ0Gs8bqJo3Opnaujc4zW4sTiHEML0ugp5guxxnNm0znIJ+ZQqzOc+76ZWy7lao3RdFJE27dw4StIEoWMkV2rgqoE0usSvUQ0uI0NPRz+eIYolBDZYKhqy8g+RWy1QJCqI5szqJYrBAOK3z/+89hCQqOGxCN1jFTlLg8ssClxRzx6CqaO2ocOfYaqXQEyRiiznTo6Qrx+svP8PMf/zB//ud/QDhqkI4VGbr8KvPTC8xXYpyarBJv6uLGqENjfT39PW28+NzLTE77XBg8xad+/kOUS0tcvXGVockZYqkEe7bv5sF77+fSmQFUOcb8YhVRiePHu5gvKOjxGM1trehGGLs8x+zsCOnGCJduDrDtwHsZz8fQqymy2RJH3niWPXv3UqlKeKJGMhTi7MAlQuE6tqzbz1JFYmBynuEpkay0haGxAtdO/ZDu9jSJmEGtfIO21i4OvzxNc8u9XLtZoLp4kdmRLHu37aelrRVJinLteomKcYBnX5hnY882otVpMuOzNKX6eGPWwAoUbBwCuQKCjSyI4EnYVImoGlptnk9/eC+qM0hLSKe26HPq4iTtXdtIxtOMXR1iNh/CJc6e3fdw5fo4ltbNUHmR+598lKKnce2axequ/Zw/e52lRYMYMmdeOYIgJ7kyq5AR6qgJHoGvLrtHiCquGODeHuO8m3MpCiKKouD7Poqi3E6xQ6EIoijgOPbtzr4kiUiihqGpqJpE4DmoqoQkLQsrv7XLrigKmqYQMgxMXUdXNfB9bCcgCJZrmZpm3JbAk6Q3G2Qrqf1yLfTuxtCbwLoibC0QsJKmBwRIiIKPrsloqoxhaCDc4o8K/u0xVt1QcT1wXfdHSgkDr//FP3/VqFrNYXZ2hPqEw4P3r2fgylnSiRaMSBeKYdLUEmFi9Aqf/vznUF2FgfkKdc0HCMXT3Bw+Q0KXePX8Ei+cKZNxemju2c3uvfewZ2sv8boUa9ZuIaQ0ENUT3LtrOzu2tnHp7Et4do6qnUcPmyyVcrjCTx8p8wOPQJTwApmZ+Wne/4FDlCs53FqFWCRKPF6PO2fw7W99k4qikfP7WSisIdDCVKU2MspabljtZLQupueW0P0iNU9l594DrN2wiaVShaVSDUEz8YQqouhSF45jl0UKSybj0zdJxMK01acQ83nmbl4gbhaYL80Tb+jg4uUcTa33oJiNdK7tIperEYgGDU3N1KoFUjGBuFEiL8jMi3HmKzodzUka64vUvMNcv/5DXnv+WZKmysWT38cunCOfu0itOMCW3gRb+3up79zCjLKW50Z7uFldj6J0cOyVY7z/V36Vjp5+GpvbsD2FqcUC2/fv4ROf/zjpFo1Na1u5dvYk+3fsplBwaetYT7Eqotf1IultlGoKc5kCVbtMIVdky+Y+JM1nrlBhaDHOiYFVdLR+BMsX0eMVylWZ114bwnYdRL9EJlPh2sA8Y9M5Xjt2hpdeOYVjpgmMLibndYxwO2YkxtmLJ+jvi+G5Np5tUswHLGUKKEKUbf170MMJrHyJoaEpFLOBrXvW8tu//fO89/E+wnU6m7b1c2PgVXx8bN/DF0V8SUIUQBF9fDwUQA5yNNaVefqbf0ZclSlmA3743BFmpyUi0U28+OJVxmd8SlaY8Zkaf/vNw1yaqHFuykPu7Mdv3MazJzxK8k4GZsPoqR72bn8X1dkltLLFmZdeQNFlaoqP44dwAhNXVHFEcEVwpDfrpW9Nl+9s+qxMLpVKJSqVynLKryjouo4oiiiKgCj52LaFpiu36qxvRo6u61Kr1bAsa7kGLCiIvogu67c3URQxDINwOHw7GoS73UTvnHB663t3KkGtEO2X3+M2UIJ/+xps28XzLHzfxvdtFEVAUYRb+8qPAPU/xcDvp613RGT6x1/8vS/8ya8/QDEzzOUrA5iCzpnDLzBTbuDFI2eJxYuMjb7Kxcsn2LRnDxNzOtVKkpmJw3SvraNUDpEN3Uti80d4+ozF9UmX0dGbXLl+GUWWCCkJpuehpXcv0UScL//F79McT1PfsgUtCNHfUWRhfpi5+Y3kldjt67rLRREJX3IQZR3fA1n12JDMc/+eCM3xVk5eG2FiVub+vWsZvbyAVqegtWwg6+/BJY3kj1LU+1k076Gg95Mv+yS8m/zbjx6gGungG988znuf2sXloSJOeD0FPYWd9UibIr318+RnLjCXybL1YB2Dg6Nk5+ZQ7Qp7t2/k2sUhHClOU9seRH0DQ8NVJClE2FSRFQ2jPoUvQjqmYRgmNdtCCfUiBR0UJk4Rmr1JY8xCiJwjn49RH16NVV1EFJf44Ace4/S1EXCyVPJ5hsZgSd+K3biVCXsNpUyF3R0audGjXDl2lEc/+xts6W3le9/9Lnv27mOpkOXG0AXaOuupLQwycvM6kWiCsbkFdu7fw4tHX2Ft2wbcsk9j3KNOqyBWpzDUTtb1rePihYvMLWlknP0s1h6ifPMma/rD9Kw3uHopg6KmuDF+ibgqMrFUR8VOsWPbLgJJZmB4GiMdxWjZSTik8Z4DJrs2mYT1GcKixsh4nkjdspCIFZzDKWU4tH8nulxDjrh0rt/BK+dybN94mYh4iWTC5W+ePs+i1s9ouY7JaYP2jp2MTuRQjAiSpyM7ETLlRaSgRpRx7u11+NADvbzwtb8hmZBobIgymlEYn7NpazMRXZXJRYWDD32EcKqJmrmaq5UexoqtHLlQpixuwFeauXjjGiV3gM1rZMqZm9QqZYR4P9fdXm4U6jDMKAIKoiBi4+Hg4wkumnh3Zx7Av6WgtAJQKw0gWVaxbQvXdRAE0DQVXdfwPRdFkdANBVlc1gut1aoosvKm4PKtV1VVcS0bx7KXlZj8ANdxEVQNQVj+LNt2CQLw/QDbtm6n3HdGip4XvH3HPfAJAh9REggChyDwkWQBL/CIhE2SyTo818Gq1fB9+3aDbyU6BwgE5a5r9jwPx3F+5jT/HRGZ6uE6Tl2pkG49SKXWRCTVh6MmSTc3gpJibFpncFomY8f5xotH+aUPbCNVdxNR7mB6egNifD1tnWs5caHKvL2FiWADi8Zq9rznV1nfv4eBG9fo6jG5d28nLXGJe/q24oyfQ6nM4RXz4Hhk57KowY/y426vQAR8HM8GRcITTG6MzJPNFamLRChmpuhZ1UAirvD0jUkW7U761x6iVBgjZ+WohO6H+DbypQT5jEQi2kwi3YEYSxI14uzcsQ1dB01ZNgP0PQfdKSFZGRpTJlU8Et2bSfU/xsXxBZ74ufdy/NQznL1wHlfopFqSmZiYRtNFVne3ocgax964gKzLqGGTTHGJkZHr5GdvklarrLYmiMhFPM8jpHWSKaZIbvkAQuphauY+psoRVm+5jxeOZFnMhSmwlmp0H3LDAS6cvoo3dpqQl0UJKhRqZR776AfYun0df/5bn+P5f/w+l84M8uW/+R6jN3NQk5geHGHJX6QqWOQtC1kPMXBzkH0H97N48yxCaRG/WkWWBMyoiRzRuTYwwMF9B0ioOtu6OyjMDdC2oZ6hSYeXDs+Qqc1i1FdoaW1nsaKQKbTh0MfhI6e5fvUNYkqV1dE5PvpQE+7Si6SNGWZvnGRucIhyuYXL167Rv7meVGKetQ0lHn7yMcYXxpieH6FYKvHc0eus2v4UM7MP8uy3Mlw+m2Qw+2m+c/wB3ri6m1949z3EKRASPQgEAhT8QMGImqTrYvzKpx6irz2H6QzyuQ8/yb7H95FolYk2NCOHmyi7Dlu29/PkU0/ynaefob6pl6GsSTGyA7vazsxihGT3XhZpxI6s4eEP/W8kf/RtAAAgAElEQVScGb3JlVKEYtMDXKmuoSI2k6xLIeAg4SLgIwcCkrDsNPHj1p3z+SvAYts2qqrefn8l/Vc1QLBxvRqOY1Gr1QiZ4dsRruu6d0V3gSTjIlCoVMmVypQtm3K5jGVZ+L5PpVK5vb/yObZt31WKUBTl9vajgikBwi1DPFkRiMdjpBvqUDWBYjGPIAiEQmE0NYYiR3AdGQED31OxrWV2wQrI3ql5+rOudwSYLlUDBtxNPHsljtv0fqSex/jlP/0W2/c18ju/+wd88IN/Qiz2i9j+h9Gjn+Hvv/99HvjAOqJKI1q+i3tXt1MbfJm6WgHTklCFECEzwff+8WVqlkI2N8NC5jxXrz5PrTzLx5/8FC2RWQYvfIeGRAn8aSrFEXx38sde4zL5OUDWZAJEbF/EMFNIoolhhqgLq7zwwrdZyIwyJDrM1Ro58+p14qEpzFieG7MNBGoTkiOxrqmFkGvx8mtHGFmyOPz8i8TDJhFTJmSIiF4Nt1Ymol3CVCeYnBplYspicrGNK0M7aOp8iqn5Ght3tdC9OU5qbYLWlgiRaJFDDzbhi5cQpGFWdyfxZZuJ2Qm8wCWZTCBYZZzcIh3REhnrKhPOHDfKMueLDTw92cy5sRYa1z1FWeukbtVehmfaiCT2MFtZQ6Tnw4yXmmlPplgnTLC5foZ372/l+Ze/w/MvP8tSZZaIlqe/ey37dxzEKkicPzFIR8Matq3dxmunJ3CkZhSjG6sW58zpCSbHSrR2t2PrBqdH5hHTa5HbNzFduUjJGcXUCjRHC4xc+Et+7t0Bcv04r71xlcEbKmVrlnByCR+RQG9CNHrxxTaW8jm6V8Vxi+P81q99nszlF9FL12gJSYyeHaRB6uHLX3mJAw88yvHjxynP2yTtdXznh8coVXWOHL3OhctZphZTvHzc49e/GuGFsQ7eGMrSv287Bx/qoavxBH2N8zz1aBfx8ByCPIcvLxEoS2iGRqVY4B++8qfs3BAnnQi4dvokV14/STSR4uB9HyRfCFPISeiGzV/9xR/xnnffTyKdZjrrQribVH2Rzi6Bq0NHKTkqmVwLJ44mOXW6kROjO/jSkTTj8m5sLUoy4SBTRqSKFDgogoAaSCg/AUxXgG8FWGRZvk1JWgGZ2xxQKUAUV6xHlpfnBbePMwwDTdMQRZFarUbJtrGCABuouC4l275r6mhlnPXOKaw7KVpvTmT9KJVq5fhwOEwyWU9jYyORaAhZFvEDF9d1sG8BfqW8XEcWBYNS0cGqgWMvg6njOLcpUv9Uy5aftt4Raf4X//gvv5Do3EFbzx6WnFVY3gLda0qEgwqLlQJf/eZXqG/oYb4SZqxgIAcRdm0SEa3rbFjfxNEj5yhqhzDrmzCjEmVBZq6axtI2MV64REeDz1OPvJ+XTsWZKqhsv8dnlXeTDfvyDF/J0tq8htNXf4jmfpwgVU+hXCRQbj25A5ADCBQIAonAdQmEGqqhkspqrOoeQwuN8spLGXp3rEVL1DM9XuHQfR/j+PHjCJUr6IrKgrQRJa+gFefYsKoORfNIhwOE7AJ9HR1EjeeJrdrKN06lkRLdxNUK/f4CHbXDrEr7nLmxyFz9fZwa1FGnr7EuksOIu8wHYUYvTeDHdMLhGGeOnGHw6g1KVQsxHsESkwSFEmE0XCHNiJ3ESnRxJruabZvWoM03ozfmWdBhofAJJisu/2JfJ97sIKPabo5dzfLh+9YwHTRwdrTEYzsa2NE+i5IIaI6V0cqLbOjSeeB96/nrv/kyengzL734Na5OzrFjx26oltjz5M9z9FoRSgnGx8qMjk7geUVCho0hlnh0970cnuggV91POrSJsYvPsr6nj8XFESamhulq3YFbypOKnGBTUx/TMzdoagzzmU9+nmouxJRbzysX44xnj/Po/W0YmQwb+7twY/PcvHiMwBpnbWuViJRDE1R0P87w2ZNs2rGLCoss5oeo5lzsrgPcGLfRYlt445zDbFkm1gpr1vYyMR8wmOvgZqaEb4+jZU9RnPk6mzpCZKeGWSymqDo6hlTBNiWaaw4//+7VzA1/i+uv/pCdyVb++HiFYxNhTl9tZHZeRjQyBKkmdvSvIRWrMpoZYjxfJVSp0rmmj8WMhRvEqLg+galzc6lGNraXamIjUmMfNVHH9QScmoeIih+IOAEE4jKtTwgCJNlf7nL7ACIEEl7g3qb8CaK47KsU+Ld4o94tXyYXWZZQNRlJsgh8D1mSkEUZAhFZVLACC89zsawahqYgESD6PoIcwanJ+Kg4vosvW2hiGN8Hq7bshHGLx3+Xlt+dACpJb0akgiDcBkDTUIibChFVIKRp+B5Uaj5upYpTc5ZLCwH4QQCKStW2qFg1bM8FScQXIAhEAiSCQMR1AwRBBiSuvvrf//l38//LH/zxF7o37MZRElT9OO7SFSbOfJPXnv4uS9mAxw/t4+gP/oRt/TarOyfZ1LmOKydm8KVJGjocLg1MsxjbyHQF8r7Omt5+qplxIkqGJVdh0+oU517/Aan2rSSbuzl67gLVfJWrU8PUmxuYuPIa8USNSOQJJooL1CWiCCK43vK0SHCLHCUKwjK64iOJAo2ySWP6KvVhn+d/MICRiLC4sMi400a+phOLRelfE6dQzIFcz65tLTilmwR+Bkkt4mQv4WQuEgr59K5OsJA3mMwlqJQLKCzQqL2ObF2guTHF1aECJWkbvrNEonyevqYKrx77KuOL06iOjVMwiOsGzckoY6MjxOuSxGLt5MV2HKWVityGF1tH3q2j6oSINN3LxOww3U3tzMy+Ttl2qFR6UAyZxYuvkpCXmLJUSmUJe/I081YIs76D5nSSfVt7+drffQmv1oFXVpifHMIrj1DKZ8FTaEnUocfSnDp9jP07tjI7muH6cJ5IupHhyRtooSrrN7azsDhNS2sLyaZ2nh1RyRm9COEQves0Qt402YVp9u8+wImjV7HcCskOn+xMBeTl0cGhC1eZmbeoqF0Yje8jHF+PWxXZuy3BiUsvsOCAEcgEosGjjz/J337pWyTqV/HSy6d55OOfQo0EXLl+GkHS8bR2Bit9eH6K+ayMGeulf/d7OHZpivmaj22DJ+oIiopOkTp/lj1rq/i2yruf/DTHbzos1WQ0RWEpG7DKXaI3PEQh+wZL2Syq2czTEw2YsU7w8tTH87zvga288PoUM8PTFHJVzg3luDxukmraxXwuQ9lykYwojrf8P1AkQHiLid2d6fXbCX+I4vJM9J2+R3d2+Fcis1snBEBVldvCzbqhIckiXiDiegDSsi+bJKMqyzXQaDRMxNTRNBlVlfECD8e2CQhu6Za6BO6bMnt3kuXhR695+bvc/T1XBFp0wyAaDhEyVAqVGpWaTdVycFwHx/UQROk2wSrg7vHVlUbbytTXnXP5juMw8Pqf/fOvmUqCSzzRjlbXg6uYRASPTxx8AMeVKBRUvvutl1mbhmj5RRprf8WBDedoEBfJZS2+d/gkT/7i/4kaFREUFUGIcvrUOK6aIEdALXSQavgAH/3lf8/5N77KxI1j5L1uRpQ9dK/7EDv7NlDvzhKUbAr2BCkdSguTuLUKgQCeIOIJKs4t8VhdlZF8H9wak47MXNVkPisROBXSsYBqJodQ10tBTzHlKgyMLmEAjeIlQsJ1Du5IsXdLmv/2xd/AEKo88eAh3vPEVpKhBCkpRFKYoEG8yhM7DQT3Em5tlKX5CZxSAbFUpEmfprvBZ+zaUfbt2siuneuImhVirsfk1VMkwiUi4RqqJtGQ7mFJ3MOU9hBTsacY1R7FTT5MENrBQjmGlGhjcH6CQwe28fCuzcRrOUxZRTYT9PWsYuTKWRxPppBxwPKplBxO3izyO3/6NB3NfdQKJbLZKTZv2crwUJmOlu38y898jrnxCsWyT6Spg68//SKy2MTCqMCpwSjzbj1ZUUKsS1PyYsxmo5y4cBNBNcjqTYz6zVwecYjqKvFQK+dOTDE7l6cmlmjqbmc+O0ZdvULvmjaK2TInjg3juWs4O2Nxc66FgckoA7ML3FwUqEkP4AhRLA9eef0q4eQBVm3+EFaijzNLScayNZL1fTjyBs6XO1BbH6Bl689Rim7n9IzOd49NkhM6mMwL2HIUQVn2EsrmytRcg6tnziD6Fv/pP/4m+UKGQsnC9Qw601E6jFn2rI6xsfd+/PhBlpqfoCCtwS6G+cxH2ti/6QZyfoyZ0ioqYgtb976HitNEOL2NxUBmIlNBMWM4dg1FuDVD/hafop8mTXfXSOgdQHunYtTKMSup91s77aVSiaWChRvIBIKMh4ADOPjYloWuKdRFTBJ1YdL1URpSUTrbwnR2RDE0B1MC1ddvN5hs237b7/CTZPxW6pvhcBhFN6hUa8wvZChXalQsm0CUEEQZSVbxfG5vd9KfVFW9y6Z6pdb7U6UD/z+sdwSYGqpAg66QHR6ms1Fke38btUyB3Q8/xoyXJNzzJPP2PUwvrKen65PMXf577rl3iU2bHsEQPsDXvv46xuBrPN5jEMlcIqXb1DDJ6GuoWCIvnavy118/TyIqMHrlB4h2jZIX5uTxDKdOnaS1NcnSok/Fn6Nmu5ihKIIsL1vCIuMj4djLHb/dO9ZjaiKKZ6Gm0+SqBpLcSNhQ6eqsJ7BVkmYTWiiGa6Yp2AkUMcSWVQExGWKqxPDVqzRE6ykullAxyRUXKRcsrp17jYh/hf19AsNHvkFM6CYV3UQpL4HvUS1dZ3rkFNu39LGYLXJzwsIVm7H9BKI2x+MfOMipqxcREq3MeyZDRYl5pwMp3k/Vb8AWkthyIyWxATuQmCuJ5Nwwrx89STIMa+od3PISZrKehqRGQq1gmFGC5DrcmoVay9DS2sm9T/4ranInE4vfZ2ThaYYWztLcuYvTp3O8+L0jiHo7G/Z/krZNH6Vxw1N0bXwQT4yhNz2BE3oQ6p7g8MU0WeURpr37ePb7I3T4NpHFCdII/NanfxlNUJgezdPTuZHP/sovUPEEZuebmclHuDgwz9HXj5NfmGNNRwfnT10gkMZJN81jhhZ5/ocX0Iz7mVjoRtNMPvHJD3Ly5GWSTQf4vf/2Q6x4J5cHsyA3cHWojrnSPpbkBxlcKPKDMxcZtxzE5hRlXSAwRdDrcQUVL/ApOy6OFKMYNDAbrOPSjIxY103RlYhF6xD8gEL5Ig8/3sf10TleOpPi9NRB/p+XUtQZdVQmrvDlL/46sSCHZfu4oTg7798FoSooKrZoMm8vIEXS5GrLmqOiECwT4mX1rpv/zjoivBl5vd26M4UG7ooG7/S2X5lCWjmXLMvLWqgIiIJA4Fmoio9tFQg8F10WUFUI/AquW0BRHEzdI2y6dLZFaWmOE48Yt5tUbxWDXokU77QWufP6VsBfEAQsy6JSreEG4AQirucTsBw1O35AIEr4gkggSiDJtx8OK59zp3A03Jrf9/3/KUAK7xAwdawqzuwou7rq6awrkaoXmc4VefCpj9LTt4HxfAW9YR2zxXrOXhIYGTd48dXz2J5HS3MK2cuyrjXM0sQR+tvzGO4xVOsSaa1MiFlsokwWG+nfsh3FXcDOXGRx5CwRM45sGpSRqXoRVM3DUaJUAhkUE0QZXwABH0VT8XyHY0dPs3Z1F5VijoXcPJWKT120kVw2Q0tbI1qkgfs2biJMQKSunlLV4OjRC/T3tjA6NMDUxDCRsMbBQ3s4dP+9XBu8TKy+DUUPE4v5zIwf4Y0XvkZclDB0nXg8jR6OohkGWzavQVVVjhw7TyClGZ/TiSR2kS83s3bnOtr7tnDycoWqsg2t8T5Ga2nEcJzc3Dims4BcHEPwSviyiCiW8QUdlzRmOM3C4jSZhYskYwY3x4cRgjyim2U+M8+FGQdZlmmN+AxePsoLR89RkFKUqj5t3d1MLOb5yj+8Sjy1htGJcaLNvfztdy4yWmyjpPdTUeuR6kwGJhaJNG9nyV/Por8Rv34/M8FqlOZ76GsMs73FJ3/zKGde+jZNqVbSdWm2vv+92H6JhazF6eMCiZZ34XitVCs+ol/Br82jSTn8zDSt6WGS4UGkikzEaOb3/+TzvOfRhzl59Dkee/ghxscLrN98L54eZu/WFmQjwEz2sVhK4UgtuJ5CIGp4koKNcEtJ/5Zc3S3/Il9UsMUwFSnFnL6ba0spqkYXVV8n8Bwkp4YdqPz5N79LZM27eOkqFIz1lI12zEiYamWO9lX3Ek4/wokFjbJjMzw+wNTMEJpiYBhJlLCBI+n44i0n0Vuz5v5PuF3fmuLfOZ751u2tx8HdYHtnQ8b3fRQCAsdC9CxUPBQcTCUgEgqhKgpi4BP4NpIYIIousgBhQySkB8TC0i0hIfG2GPWdU01vbS69FexXmlErYta242HZLq7n4/gBjr8cYXr+rRKIIL65/Zj1VsGVO8Vefpb1jqiZfumv//IL+zvW0NeeZHHxGKqe57nnX+Tg6jX8/TOHCUzQpQXe/+T9PP/is1jFA9yY6UdrybFzv8XjBzdjyyYNbXD6wt/ya5/dTrMyQV+0xkIhj2/0gNxA/uYz/JtPP8Kp46+yqaeTVau3YXkFJmavs1DQSbb3MM1aPC2EhYwgysviJp5PQEAkpBPSFOZnJ6ivCxOpa6DNGOWrf/J7eLUyerPJ7GILhXEbMawznqlguDJRqUbMHCPZ3EpPV4ofvPAdjpx5he2bkxza1YyvtxLWNAqlG+x61wYq2RJNRg/N/WXGxy8zly2TaNtIxmlAUmXUapX5mSznpyxGluKkwxvYcSDJ66czKNH3sRgcJMt6ymYvriQgLlwiHUwyeekw0aY0RUnBkGo4QgzZbqEhMsYvfeoJXj9yHLFuDYJQ5NHeKicvX+HUuIzSsYMmfYnCyDH6+tdzsyjjCFHWhvoYHJ5j194HMfVmKpUiC5nXCaX3MyFsQ4jvIl8S2by1jZMXX2ReacSINTI6L+LoHczbBhU1ippM8PA6F7wcjz+xj9zoMyiWhet4zA9dJO+OMTwls37Nb3DpZh4zlIDSOFu6o4RCCnpDM3JtK5XCn3FwSwhrNMxMJU/DzjLBjfPMzJ7F0LqYnEkxmc2R9aapLz/LxNJV9PSDTOQaWHIkAjGGKBmIgo4oaCiCghZoeIKETg1RCLDkMJ5oIAoyM0ErixWdmZKGo6dQEYgEZYTwbuoiKiQ6ODGtMOtL2GoZ3/PIZk7R3P4E3z1lcEZrRauqPHaohSPPf4tabQ1ZfzMlMcAXdERAETwkAgJBwBVVpODNyPNOHvSdwAlvOnguT/+Id9VM4U0+5536oNwGUx9R5PZ+RBFRBJ+YqZOIm+iyj6mKGKE4iiyiaWDqEpouoCkCYqAhyj6aLiMIAYqiUaiAZVl3UZCWwexHfZuWRZvfBNvblKsgwBGkZeUnfLxAJBAkAkkh8AMkSWa5Brv8PcXg7cVSZFm+DaIrr6Io/q/RgPr9//yfvvC5D65mbu5p8t4AsWQrDz/4MS5c/x7/8rGP0xs7SU/HD1D8YerEVZwtdaF134c78W12N13DXvwas1QwNIE1nfUszHyLjoRL6WoTq3sd8tlrlAWD2aADP9rFpp4IY8VdnCiEGcvWMKcukc8sonTuwHdCOFoMMXCJWgUMRwA/ihJarvlYvotihPFkjerCPLKdIxV3Ea0hal4nQf1mzhmPYRoLPLI1jJVZpKslycK15/jgo6uZGBjjK3/xFZ44sI+GmENdo46bXWBiaoDDr15h68bHOXzkMGV9iPkljfb0emrFURYmLnP58HX6t99PaeI17NJ1+nYcouT5PHZfGF8M+PrXBlm9ZjfRxhHetS/N6LFhRB0S1UF2tspYY5d419ZddIbT5HIiMxUBKZzFqGVIGXVMDpxnohZmV6vPui6RU6/NEes8REudyCOH9jE7Ncn82HVWdbRih5Mo4WbyTDAzPkDEaSIsR/jQR/bwzFXIK1vwapCyzzKxMMDlcpywtpZS0UGUVCzPXxaTCUQiaoyZmWlC1Uvc2ytx9vQrLF24yPODs4jtayjeHGJpOM9Zr5OMs5uiPU8ouExfOsK+Q4+z6IS4VmjEzEv0ta9jsvw696yPM/3sccaWLrP/4KN89eU8g1Yz3ZtaqGReJerX8O01uHI7c5bLUqiVkFdAEwUCx0MIwCPAER1kP8BHxgtkZM9B9izcQEASZAIphCAZKCzbcNRklZqXIW8JDNycR1VUNEkGT6JencJ0C/iRToJQC0G+RktdmS2NeVrjIqcnAqbVNmRtCckBSQRvWXUXDwEhcJFuRXArUdwKIf3t1jLYesCKA96tV8EnCAR8P0BABmQEQUaUZARp2fRYQUKTFVRJRlRlYuEoIV0nKmvUGwYJ3SRZF6I+qhPWJFRJQJNkZFFC8Jfn5UUkJEnFqrpYgk+1WlnmkMoKuiEjyQ6eK+B6zjLzYMUx2BPwfI1bkiwIgCgtPwSkwEESuSXp5yMJATIeiiQjBv6ycKa//AASBQnfDwj8AEEQ8f0A3w/wRGnZNloU8AUfX/BwfYsbr/0vME5aruQ5eekCjpSmvvUJ3jhTz8nLnfRueBfff+NL6O0DKMk59EjAxMQiMek85fH/zvZ+G0nJEG+JsLarm5ErNSYvNbFwfR0A3zryGTZ3w4Zmn5iTRSsrDJ0q0pp4AoIlHEXFrVuF2bOX7lWtGLMnMOVlIQY7kPBkFVcR8BQPr1oGy8YURJxSkfzMNPWJRmo1gbq6JgJRoFSYxLVGaUhXkSSbs5eHmS4FhFr7SK+9nzfODXJhLM+8GyfV9xANG97HaKkdQahnKaeiqF289MIA73v351jTuY+pyRCToxIL0zL1kSbu2Z5ifYdGJZchEWpBWApoVSXCcpWxqyfZ3ityz/o5Ht+3QFfq++za9AP2R1/jk3ssProXwoWXeP2bv4o0802c2jUSJlDyKWeKeE4NN8hSrBncGM8xvVigUM6hiwV6N+zkH16+yPVyAje9idGxMYS5s8xOF2lI9mP7aUpKmkk3wTOXAop6D3KyHs8o0dWbZvjmAoLXRcaRKaNjCyqCtFyLUwSfQsUibKrkF6dZmBrh4x//GDfnZjDbtnMl18PV4BGi695HxPBYMpsg0Y4TmLxyZpj//Q//gb88VSUr2tS3mJw6/RoXruV59rLKGWszvT3/F7/5hTdwtdVs3n8fz79+nmrQylB5PTdzzQzPK3hCFCXwUUWwygV0VUK6bUf89g2St253R1cCgigTiDquLxCIApIkkgrHuPfeQ/je8lhjMuqTql6hPl7P11+4RiG8mkBREBznrvO+1bhuJepcmat/a83vp6X2QfBmxLdsebxs5RPIPr7g4wXL+57oIsoCiZhOJCJhqAGGERCL6yRSYVTdw/NLCJKNKHkEgo0fOPiigiAbFCoWjidQrNhUyzVM3UAWFGRRJhqOYeoGmqkjyBKCouJKEq6k4EgyghjcZhSIt7yagLui1Lf7/VfqpMBdv9+dv+Nb18pxP+t6R4CpREBEkxACWMwW6FjVhamrDAwtsvddH+D0JZdY8hCe1M7Oew+yeUPAv/3EWgbOvUwgJBibjDE0MI1fdRFdH9HVCYdb+M9/+O/51pe+yKFtzTTpMzSY86jCNJevvEGlMIoo+YQbOvHqe7EsC6M4iOTkwbXxRQVXUvAkAU/2iJomLY0pasU8kusSUVQCUUKUVARJIxQK4bt5vMoohbEXkcoTtNQn2bJlMwPXrzEyPIPvCJw6fZGH3v0BbozM8/zh0wRBDDNsUrIdLNEkV5aQ1DQ3h7O4gcm69f0okk44ZNC/JcLAue9hmgGReIjulgR+/iZdnSHOn3qJj338AE2RKaTCFS6/+neEvHM8uc+gPT7Hs9/5r3z4qV3YhQHswkk60hU0Z5GkKtEYDWNIDppewzSjjE0t8pVv/iP77j1AZ2s9h18/jiXHIdHLop9AVFSiQRbPg6WMjSgnibX2UAu3cGxEYqYWJTBCKKGAVFJHkaIEQiuuEsYRdTxBQUBEEJcDhHK1hii4bO3v4cUffJfMyBjt67dS9lPMWB1MSnsoh/sxFAtRdoiZInFDxlAMHnv/z9G0YT9KVGPPvZsIx3Qks4Oy1o/cfT/tq3fRuGonrlHPSyfP0LVhP/H4HqzwdtzwBsp+HC/QCSkgBjZdq1oRA2uZPiQC4o+Xg/txmygsN0M8SSaQVAJfwPc8StlFLl8cZGhsClXXMBSL7R0iFy7eINS6i4xfhyt4GLL+Y88N3AUMb0c4/2lgurKWQSZAEHwEwcfzXQQpQDVlQmEDRZEQFIiEJExNxDRFFA0E0Saghig7aIYIwrLbJ7gEgQPSshG9H0C+VMb1A9yahRQsW6vLgOC5RAyTcNhEksDx7GV+rCgQSG8KtAi3atWKImEY2m3/ph9XD367h9tP+y1WjvtZ1zsCTBOxCEplicLsMPu2NzI19FWaY2eI1bfwg+cVzl74FX73D/v4u2cbODpRZuO2NmLuKXZv3M+LLxkcfm0H00MWhjrF5q0TbN5a49rlPP/wNRVdUTjxytcJ+0fYu/kGgv/XDE78No8fbMSoDOIUMszYCWwjiVOcJsicI6qUwHdxAwFXCAhED1+wGB0b5FP/Yg9WKUdTfYz29maaWluYnsvgegGf+Mi7+Q+//jF+57M7+eQjO5i5conhS6+Q0HJ88KFDXD91iWvnL9GcridmSBzY1EurKSAoC8yXZilpBnkzzd/88Dirdz2G5yyQbi4hanni9SZNnVF2bEki17kUlCL1qRxPvaeb8YWrNHeuITs7RHbyBpXhChvqdzB3YY5IeAlXKzOSmSbc0cxHPvM4qdaA3vQskfJxmqUbbGoLuHz8e9SHfNLeHMmozo3xKcbml8iXa5ghEdsXWKoEiEYLRqSJrq5u0inAtWhINlDyqmQDmVpsL26kg8VCmXJhge1b1yFpJp5aD3BX5LCyYqbEmo464oZDRJMYHJxgYFFDjXWD2k7R2MisXYedmWGtcgUje5QGYRHDWuT0c99m+ORzKFaGcNhGUIryo40AACAASURBVEX6t76XmSUVR1HIBGdoWdfJ6ZFJiKWZzenMzrVQENtZcBL4ahxTN1AqM3i1HDhlnFoJUXQB/yeKFP+4hoksiASiiisZ2IGI6y83svbv2UGm4lHftpGlClSKGVrqLS4M51mU+rG1FKps4Qb6bbC4U+MTuEukYyU6W+ngr7z3dgBypxWyJCrAslydIIAo+UiyRzykUhfWiJkqpiJgaiJRTUJ0bASvhqEKaMry/WB7NSy7iO2U8Dzn1rkkBEFClZbZJ57rYFcrOFaNZJ1JxJRIxHR0xUMWbAw1oKFOZnV7ClP3EQSHAIdA9G89zJZn8H3fJcAj4A5XAPFN19GVsVNJkpaFqG8xBt7aVHtrc+1O25L/GWr77wil/YplcXk6T2BKOGcmaWnZRCFjUyhUuTTq40f3UNXWULIWmc4WEY6eole4jBLex8Vhh0RXDzs7XVa3GfjVy5iaTqbUxGJJoDKpoZoKDx/cx3/5o9/l8fc+QkdPK9/46//K+pYnubYYUDNa0Ds2YQdjaKXTKMIm8oSQEZcbUIjkagX0kMKXv/Ya9z10iOmRm5w5fxgtdxZr7AatokNXWxOileXY+TeYHpTR4z30bmwiqecQggzR9r1U9TwLrsq67jZC0RKaWMQqFpjP21SN1YiRHdhaiUlacJb+DEWeIBJVqdn1nLtoYuWLzDt1JOpD5Jx51sb6+M2/+jamto89Xh9nzp+lt72NmZuzmNF6nnv5RQSizJQVTlwaZW5mnPc89iAXrp1lU0Mze+/p5vA3/paWxjpEz0Mbf46PfOITHDs7zPiYjVnfglu4Sn1MJJAd/LzLWKXCxEwBa+k16g2DwIowkxslUDtwnRZ8xUHxJTRHpZotYlHFDTuEq0V8X8BDAlElQMQXRcJOhbhUY2l2hNWrV/GdH75B0PIYhmySCBaYKpbQQwJdqSY+8692cObkKPnrdZSmZkmaDp+9t5szZxaIK40cPXGWILaGNalmdjdPcOXaNS5c0mhte4CsJJMtThGXdJIpA11JMTEyyrYd2/jhM0f5xGf+Dd995gUC16cu1shUNocRM/ErP74m+bZpIz6BIOGhIokSAjay55GvZiCSYsmPIUoh6uU4FXOevNJGgXY0v4QuLFIVOtCC2t3nXElhBfF2A2WlQ36n9cc/ZYnismI+goso+Xi+haYq6L5PVDcxDQ1VFPAdB893iBkaAj6qrKHKArK8XBPVNRXPDfB98dZrgO8FiFRQ/CrJsEZV8akLafiSh+ssq/nb9rIQtab7KJJDBZdVjVEW8xY116fmuMiCSRB4gEckGsL3PWynxi26913R5DK9iR+JPAXe/JsVwPT9ZX3XW/+C3NmM+1nXOyIyrbguamc/0e6DjOe7yJS2MjHdx6b+XYSbCqx/l8GSWqIabmPO6mdsfjXtbRup+TXW7VqPE1qkoUlGlhxKSzW8apgLl05SlU/T2L6bqUmf46+NsnPtk5x9pcS3/8cwjRGbj923mV98Yj+JaIQlR6Np424a4xa14gQRU0FiWSxCQkDUZWzRo+ZZHD1xlJpj0b+pm70HdlFzLTZu3Mjk+AR//MX/m796+hVuLMlkxCaO3pjGjtTx3PEznJkCN9FLkFzDqeEJvv38C3i6jCxEmJioUnQaeelkFkvdzJe/c4Nf/aVfI2LKKGocM9yHa29neipGrHE3RDpZu3EHptHG2r4PIeoP8pdfPkeyZSNnL11l33272f9QH0dfPY1T8+hq7yE7s8B77zuAXFlk5voZ4vIc7alFPv8LD/PgvVt44qFHeKg/yRsvfIv8Uo6evs1s37eTwMuhelmCpVF6m5LEEm148V62bEnTvSqKIRVpb9Ko5MaJh6NIQQXR9UlH6gmpETRTArNGSKhRzc7hW2UEISAQBRAkqrl5/uj3/wPjw4PMzc3Runo9VT+J5Fhkho4Tckap5KaIGxF+5zc+x8ziFOGONRBvJFKX4MyrT7O9pZFv/t2X2dC/Bc8VEUtjNHmXGbvukoodYHG+jmLZId1osqbPZGHmMvGIT600z9TIFe7Z1M3JY0dQpABVhvHRUQxTu82P/Ilp/Y+A2C3+o7Cc7q783TPPfhc1Wocrx/CkKNVqwGTZx5ITuEIEzbfQghKOYPzIPbISXVqWBSxH+LZt31U7/Ekp/Z1rhaKkKMqtuXqFcEQnGY0iuy4GAhFNpy4UImGGwF++C1RRA18g8EUCX8K2XHwfBCQCX0QUdBTFQBNcDBlUwSVmqsRMhWhUxXVL+H4FwxBQFR9RsJGDCmHVx1QDwppAWJcJG8ve9pq2nNbXajX8wL0dWb91yGAlQl3Z/3G17H9q+eP/73pHgKkgx5GyI0RyN4glNjEvhhASwxRrk2huErkiI/gLeEKZXNXAiu/jxFQbqVSIlP86P7d9iaSpU8l0M3qzl1OnR+ltFNgcRNBlk6rvcn1pjDnFwuhoww81Mxz5LH/35Zc4/v1/zRObr/DvHtrGh9YKvOuhXoKBNzAzU1QEj2pgY1gV5EAGNYxQ10RJizM4X8OeGkKcHqQ7rFKxQ2StCN1tndTNnScZS0EoQcgfZeziG0wV1rJnx/tZI71OXfUNRqoHmBfeTyjQkDwLO95GmYPs2qqjOs/RX7eZOTXJ0oSJUxa4MHSBK/PXOS555GIPMZbZQSiR5u+f+RJDU71MWXE+93/8Rw499hDJeoFCboiTJ37AB97729QqdaTTzRx68B4uD1/hhWPHKUsRWpgimDvPS6eOUtYsskunaO4KyE09zW9+dBdbjBeZ+N6/I6ys/3+Ze/Moya76zvNz79tjz4jcMyvX2vcqVUkllUoqSSxCIAmxGmGDDW7stofxuOeccY/d7rE908czbgPdbtuAAZvFgEEgjEBoX0slqVRVqn2vzKys3PfY48Xb7vwRUYVYjOlhTh/uOffEi/duRrw8GfHL3/39vgtXV1I4Axs5efppPviWNQTTI9Qzb2K03sp7fu1BatNnWRw7xJx/hbgXw9bjrNSWcNrP0sZNZMJ5zv7gHxiSI2Trx4gq50i3GJSEpK9D4733DfHBj3wEVwzQP9CFvmobxZYekuu2cO+9H2Alr/Po2TnceB/FxTbOv5bngfe+nWLlPPffNMg9v5Ii03kDyyspbh8u8YE7e/mbzzxKovcmxrNpZKdNOxUsb5HFYI7+7DC3rOlldTZg3aoEoTQ5t6IxE8ao2AlEJk6ghQhT/ohH0RtB5jGl0PBRwiWSDe66Fmr4URpdrZAIZ7ECt5GpWh6qVKMSKDKpNLJWIp6uc9ON76OyUkS4BepkcenAVsvUo4BAKHxCIj0g0gPcqExkRngyoBbUmkJmCokgko2pJERNyxGE3xSVuBZkGlt6bIXSJSoy0fwYCeWQlTrCqCFikoVaiXxQxZUeoVYj1ECPO7j4RJpCaAJpCDSRairfg6aD1OsgK3hSJ8ABLQZCR4gI31PYtoXt6FiWhq6boBwEGkEQgWrCt5REExILMEWEFBGRFlGXPq7mI00FeojSAiLpE1BvPrpEIkAaOkLXiBCEqAYXv1mLRZNoptFADDR899BEA0HA/w/b/F+KYKrrcd7xwEc4N3qR8bFXMCW09W7jkccfZ2lphdMHT7LKMGj1rpBxH8csv0671oIlamjhVQ58/1H+7h8O4Yp+Aqsfzxjm1OUCgxs2MFoawE/cSWC/iZLcxmgxxrnSMspOozJr2Xvv7/DapRqf+d4lHvijh/jUp5+lradCNr2CjNrxRQuVeBGUfX2GvkHMyZJfKfL973+feq1GJhGjJenQ1hJj7471qNo8uuaTL8MHPvIR6laM7z75LL/6kY+wsLSI1AWaZVILQ8oVi8XpPLZ2gWLxZWLpOUTmHJ/67KMo2UKuNc26DX38+kffQ6rrNiKSZBMpFherjE+WSCcM4kaNI0ef4RP/7T8RtQ5xbDqJ1febfPvMMvHBXVRkhoPHZnnmjGBE3szWNXvoad3K1776IjMzdZ56/ACvPPcSR46+RLWWYGpcZ/JKnX17d1O249g9q5koG2RWbeexZ19jaPUazHqcyqLB//1/foWThybJGZ30anE8Iup+SOj7TFy+RHlxgltvWMu+fXexbt02zpy+zJbV68hPjOG4ed7/1mHuefvdfPIvHiPXmeDM5ATLxYgtO27FjuW4dOY0u1ZnyUVjxFMWN+zdy4oHE8slbrnzLjZuW8/kq4/x2sEv8WsPbsW0L/HKa99l+44NXKjMUZZ1AhXhBDHMYpxMfRWttsuFc8eJJdIcOnaBpaJGIkzg+DFiQRKtrBPzUzhe6kc+q2/MenwtwpeSQJgoYRKGDWxyhMIXOnVsPGXgK4HUJYGy8QOTul8knnTRZIEv/+M3MO0Eut1o+MhmgNREI6hIBLrUrk/DsNCFxNQNTF02gqYKEIRoUpHNpDCaNWlNMxCiISqimjqgSkWIqMHz13WB1AJSmTRBJAgDRRBESMOkVK5Rcz1M0yaecJASwrCRpeuGxDR1dF0ipALU9e57I0uU6IZE17WGj73ewJ/GHYuY3bhvQxMYspEdGoZBPOHQkkmQTjmkYja27WIYHrrmoakIEeiYNNAAMSuOVBpSaWjoGNKEMIQoQEQ+UkXYpoFlyOszZhvYpoahgakLTF3D1CS6jLBNDdswfuE49ksRTIk0ZlYisMDxr+CXpnnmpdOsWbeJtlyKuDC595bb+P1feyv/60c38hsPbMMmycEDx5ifn2fT8EY+8PY7sNQCK4sX0IRksHeAqclXueV2B9O6gqgt4OXztCZivPuBe6jWIxaibpy+fSyUc/i5W9j04F8xuPWjlLxRinPP44QCJR3K9rX/8AaFfJVkIksYSKp1WFwsMjWzQBAE6DIik7DY0Jng8vHHqeSvkMsN8YUvvshstUz/hk0cOX6MwaFeHAuEDIklHKaWZ+lIZ3nznjQ7V28iF9uBJzrIdOxmZHyBnlXdTM9N8Mm//iu8+A5Qkhu3DvLNbz3Bcr0dZMgd60xqU6+waW0bdU9xw+77mJlqpVI7Rcoax59/haR/hQ/c/ybasy1MXr3KJ//2y0xVDGpamlvvuAtNuswuXKWtfT1HXp9FiAwiXGa48Airg2PcOuBgYVAK4lwtw+Wzx2lr7yLVsZatO/awfV0fscIprLhAyJBapcz45XMktIC4KhHoDotlwQ2772Jxcg7bL7HKrrKlu8wf/Mf/Qnvn2yh6VQ6cHEHmVvO9gxeY9TPsuGM/rpR8+DfeSzIuefSJxyiR4sCJUR556nk+9ck/5/zR86zv72Pk/FH2772Bm3bugsBg0VvFYlGi6iUSYoWcUSDMX+Ztb7mZJ599krqRxGkdwMkOE5MVhrpSbBhsY31/B2Elj6oWfuSj+sYtoi8hEBohRoPKqFw0zW9sYQ0HYWRQWgzDMAiCCulMK/gWkT9POrFA0pjHiLVRj2RDA1R5jeCiO2gINAS6lBhSa0xNQ4aC0A8QKkTXFLrwkcIjbWt0ZJNUy6UGv14IkDqyUWnAMLXr09Z1dKkAl0jV8SMfpE2lHlKueFRrAcWKy9JKmfnFAqVSAUSE41iY1huU7rVmoCZs1iwbMKsoCho4U61hL6JpAlSAJhv+TJoM0bUITQsbmaQGUoTETEkmZpBLm6TiHnHHJ24pHEOCHxF5DWFqz62jSw1TN7BNC8eycWyJY2sYusDQQQofXVMYOs3nIYKgydSK0GTjfqSIsEyJof/itdNfigaUUAH1wGf75i3EYjrVmM+KsgkrCsEiKyWNR594DTcYZ9Wgi1nIsyFncqU4hBFbh5MbZvzEt9l81z6ujD/Hvbt+j4PPv8SNN/ST9x/n/n052u0sicQAM8s1vvnoN1CZO8gHOY6fncBbKlAzdRbjvfR0ZlkVP0wuKTlWOEEk+8kHuev3Go/HqdVq2JrGfF4wsVQnkbOYy5e4ODrGk9/6J27cfRtGGLFxIM25s6Pc+753sLLwMBOzk5z9/sN86N+0UV0ZpyNVoV5bpqaX6MnlOH3gixRLg5DexFLYTn36NdbfvYaVwmXeeu/dnH14iqt1C8E0Jw++QBjotG94B1OL0Ld8kZ07h3ji0aeplR22b1ziysmDxGKnuXJmgrmZUW7fextpkactmOJypciq3fuZVZ1M04afGOBN93+Q9mwXjzy3RGF6nqnx17ntnf3c1/M6UW8vxdgAJ0gxXQ4o+Iq4biKzLVyem+DujZs48crjmOlZlN2Jrfcx3N9DtViiWFiiUFhCb+tisa7w9BS2DHFXplm9oYPJkZNkBu9luiK4/64HuKjt4NDoWdJdHVQijb/9yktsTGU4dvkSVlSjJdfLqbkqfak+fuOD7+TMC9+juGizc8dWXj95hnZDYSmboe4OXp/WScQkHS11suEi1cULtGRz/Ne//SLtq3eSVwmKdYkMyswtX6BjOMXM/CxVX2ClTOqhh0nyp35uNWkjIo0IhXJLxMwqXmWJXMcGKugEQYIwCKgWFujtCtHiIYUwpCVWZur8D+juWKB9822ogqRQLWNYTcqqFyGlQNca3XHHMajVak34uiAZTzSM4/DxI9A0QU9bllrdw7Y0Kq6PlDpKgBTXmD4/7IQbwsAwFLohcEwNPwyoVCNU4KE0A1RE0kkReBVq9ZBWXRJFPlLTiKKgoeRHiIoaAVWqRmKglEJFUcPXSajG1l1TRBFYRE3YkyTwG3VbQ9PxaNqPRCGRiBpK/hE4cQPLUPiOJBGYSFwipVCqhqELbEvH95vNt8hDEqLrkpht4nthI8OWiiD4IdJB00ETUK9XsW0b0zQIo6hhZaL94vXTX4rMNB7TWVmZZnX/INWZSTb2Zdi+vY/uXBc9q1Ks2zZETabQMhu5tJQgIEtqqIModRPl6Fa+++LrHDt1kvGxK6y78Xa++oMx9K4HOLc8wJkjMwx2DHDoxX/m+KGHmLzyMrXSFJlYRCoVY2Fmhq6YTiyoYVkWk8WIMyfylKeukJIXSKhFzFr7dbybEApNb+DfUq19/PH/9ZfM511eOXKKy1cn2bxtI63pOOsG2zh74iDDXd0cefEAca3M6qF+3nnvfvo7M6SMgKQD6YTBcsGluFQC/xKhN4dQdfK1KdraYsRikroX8NB3n6TgtdHa0YIMpkk7Beq+ohi14htJLuVrfPu5M1jtN9E5cAtPHXgV3S5SqLczFa1jKbWXfzrs8fIFl4vjVSoqQ80aonPD/WT67+b0FZOvPXySlw++xplLR6lGE2zZ0c7U9En8lA2ZNE+9+ipHTxzng+/eSZg/i68lOTNRpHXNzbw+ssi67TdB5CPqi1i44FXpbO+gs2sVCyt5luo+S3VFaMaZWZhn3dpBVnWlOXTkFHV9A8M3bGQpLxgdd/nomwdJFM+R9KYZamvBK5cZvTyCqhQ5d+oMW7fexEDfBr72lX9C+i5zlTyXp5bpXrWdhNPFyweeZN/eIVrNBdrjK4jKJGuHe1lcLrNUUGzeczeB1caKp7FYdbESNgPrt3DqwjizBZeCC0XPpBb+ZDPo2lChQlcaJpKEJfDdGR575POE1WWCaoXIb2w7k5ZGd4tN4M6zZlUnT33va1w+9SJvu3Un07PLRNLAtGyEdg0h0Gh6EkaN5qfienYas2ONrNhzkRIc08CxTIJ6FdMQ6FJc57FHYaNbfc0jSdcb2/OGXVJjJxXg4UcBSmh4gUJFGmEo8MIIKQwiJdH0a2EiamSj14SiRaOLrmlvICu8Qd7vRzrlIgIRNF8jQmoNdlZjbSOr1USELiIMGTZLGRJL1zF0gWUpbDsiDCpI4SGoY1vg2I1mlqGDroGhSSxTx7Y0dE1gWwaWqWPoEtsyiDkW6VQCy5RIEaJrEkHUsKb+BccvRTANggqbNg1x9fIolw8f5uVnv8trh5/CFiZLy1c4dPoliiLJiuoiSGxjsRKnZaiLC9MJfGM/vRt30dK3E6NtI37LVuq5uzk6t5NnR4fRo7v5xlfPUamEnDx3kDOXXuEt99+GrbuYWsTouRP8L7/+XnKGR8rSEelW1g3dSYuh0ZGawPSnSdPeUBvXGtg3TQMhIwIjwcjkIptu2IOTaWVo/UY2bNtJOb9EKq6zdf0AWuCzMjHO1jWdvHzwBdoyMYZXtZGN62xY3UetuMw//P332LllN+nYPJXKMYR1FTN3mcBbJN4aw0kkiaV6SHftxLJC0rEqd9yyhppbZ65ikPc09KEbWXDWsqJvw2jfxUwFSmoFOt/JVOJ+8qt/j6utH+RIfiNR6120dO+ibmzg3EwLxy/Gee2kxE7u4fLoOKs39FDxrnBl+giPP/ZPvOJn+avnTjNr95Du7Ofrn/8SPXKSsp9B2YMs1TvQU+uZnFWUixFRfZGoWiCTjDEwMEQqmyNfdXGlhisNCvUQJxlHaiG6dDl9/iqt/fvYd8/N/OUnv4BudrAmOsOffvgWtiTLpNw5KtPj3HHDdtoyKVJOnJHLk7zy8uvcse9OVrW2cWnhAsKJc+td72D95m0kUh5PP/0ZWhNnabHHSNklzh6/iG304YfDXJwssVjTqEuHyLCYXphmdKqKlRoAowthrSLSOqiGuX/xcytDDU2BoRTKL3L10uvk0h6WqOPo4FbKaGFIS8JkuLeNrRv7WJgaI2V6mFGBGzYMs7CUp+Z66JZJGDYwkrbpYJrm9YaX7/tomobjOBiGQegHWLqBrgkyLWlac2k62rNUy2Usw8RxnIbSkt5AEti2jeM4OI5DPB4nEXMw9UbNM5lMYFkWlh3HMh38UKHpBlIziJCYpn2dKQU/LqgSNTM+0azNXpMKVAhBI4Bes25WDbFqQYSuCTQBqBC0ax33Rh1XI0QjRIUCoRr8estUZFIWStWIxQ2cmI6mR2h6hBPTicUNTKthFe359evW0ZomsCyjQT4QiigKCAKPIPDwPBeayZFlGYSR/wvHsV+Kbb6SMXbesJ/Zi6/SMlRlsNvDigeMn3yGqNbP1v6tXK1PUldpVLWdyH2FuL+W3sRp/OUaxy6NcdvaNIuLJpeuVMhHrUgrjQgcivog+ZUSQ10WixdK7Fm7mTPPP0Hn4I1ElRyRkeGhC4fIO1fJLmxl1pPMd7RieG1s716DHnM4UbxArWYQRhq6VSaiShhliCzBeL2Vtl3v59h3/5Tnvvdd3veWTXRsuZXj334CUX+K8up7GVMhH795K3/+qU+w0NeFtNdjeJdoiQo4Zppbd93KgbJF1fgUbWuXCWREm5bi7p0DlIOr1KKQy8dPYw9sxr/yKG9/r8aqQRPvwA14YS/O8rNkWgexEjBfdpmfaiXe+puE1q0UMhsJQ0VQCrHS61gKBEXDIFJ5HNvCpQMRzZC2Krx1neTRZ5Y59soJ2nObCTUHZ2ALV6dbiSe7mayYGKl2klKxOd3Lb/3qav7mL0cYnV9itC2HLW9ndXoI/+zXuX1HDb3qcvRUH8fmjuBXBojbCRaDZe6sHELkNhDaRXY6z3A+dx8rx77AI8E5duy4i4/91gcoT3yOp7/4B/QFil/9wD0UaikOPvwaV8qzdOQ2MztzjPvf08/S8mmy7VvY1HGV/p4qRu1ZplbmKYQ5sDYR87JkojJmtp1Ju5VZz6fkZlhfzNOqmcxUDIToxVRVNDvC9SIiYeB7VWxZpctUFLU4eDVsqiSskLPnjrNl5yYWq1kCUUfiovkl6ssLbGjtYeHKURIDe9CdOmY4hRXMU7sqePrFw5y9+DxhEHD3nW9nIRLolkE2kWWq5OI4caIgTx2PQOqYZoSBiyk0AiUp1sHwK0girHgMTUWYmg1Kka8sk8zYzC+XGv5PysfUHGKJBIauYUqFbehoUlAuVmmJO+TSKYIISkpRDgQ1H3LZFPVyETPQiFkGrekMKakhpSJyPSJDEZmNYClREIUIJFI1SQRKQ0VN22Z1zQhPIaSDiqKmhXQTESAijKCpiBUqUDqq4RFAFPORYYSINIKahyN1OlNpAgl1129QYpHIoMmGklVCDQxda1qqBMQMQRh6EDVFtKVOJAyEjFDKuE4hVUph2dYvHMf+1cxUCGELIV4TQpwQQpwRQvxp8/ygEOKQEOKSEOIbQgized5qPr/cvD7wr71HsR7xN99+gVUbdrNr8wAP3JimePTTHHrpeWrLU0h/hnXDNpY+hx9dpaCVsaIlUvXTrG5dIpWIuHPfTjJRlWxhlq7KZVTxKk52iMvBRmq5dzNWvpMo8VaeOzTF5OIY1akXKEwcJSslo8cmuP/u26i4h9myoxPNuI3TVxL8yV/+Ds8/+7e0+BV0rQh6SGBGhKZPZBWxjU5so5P23HoG+/fg+x20tu7k/OQ5VqhybuIo1bmXGGiZ58VnvsLEyAU277yBA0cOs3qoDT2uMVGtU60otNQQC1E7RqKN4swEv33fPi6ef4HAnSJYOU+08CozR/+GXX0rbGjTsdyQpNOGaWbR9V5K1ZCZOYlwhinrSaY8HzfTjVISTZoYutWoLxHiui6B5lAWDlIL6bBrlGavoITOvLiFzN4/Y6TlQa6k38OZ4lpqdh9LNRsz1k6pqlgsSEaX4AufeYxU7gRpWUTWNMx0kXzYw6rh1UxPXcGIyhj+Cl2pGJYfkEku0mtNEjPnubHzPB/YMMvkgS+T6c0wuDbLxdPHufXGXk4d/R4tCUG19BprNph87vOvcvRMDKu3zkfv2U+4+CrbV+eZvPg8Rw88TcayuTQ7TWibjM3OMTq+Qq2aYW7CQjN72Lbzfs6NKC6PC7Id23Bifdx2Yz/vvGcPuh4gDVC6SWD5hKZHZPpYCR0lfQLlklRlhjsCktp5vPxRkhTw52qkqBFDIUKDVKYfFevn6ZfPc/b1Q1w58xLF8QMsjz6JVn6d8RMPMzk2QmnldbYMV3jPW4Y5+8KTJM3jtJpX6DaW6Q1cOt0amdICWb9AQtfx9RxLXpyqZ2D4Ab5QCMei6FZxVUjZd3GjACljSOGQTbVhCrNBSfUVPkZDfd730CKPlAWtLTbZpIGt+STMOkAXXQAAIABJREFUOpYqEVXnyFkRTlhgoC1GT86mM21gyzJh5KLp6noH/5ra0xvHG8VXfvxcFEU/1aceGrVXIRW6rjURAE2UgFKISEAUYRkCTUQI5aGJEFMHx9LQRIQkhMjH0CWGJkFFDf1XKX7YdDM0LMto3lsDtK8bjXqpW69Tc13Cn8F0+3nHz7PNrwN3KqW2AduBu4UQe4D/B/iUUmoNsAJ8tLn+o8CKUmo18Knmup85YiYEhQu8dOCfeeuv3ceTBx4m1Ql793eTzS6TNJe4YV0fKU0QxyDbsoME3ZRnxpkbf5VYLM8LB7/F4vR53MVRbDXN8KDN3PICJaeFRVopmWvw42uZdQ2qesTc3ASV4hxJx6a67JOwNNqyFWqFS0xPQyy3naENAySsEuQvkdBNTD2JFBmQSaRmUyrOo+khVbfEBz74K/hK8eLLr9DT0oLveXRkYsRL4+xoN5i7cI779t+IQcDixGXC+XN0JOq88urz1OsCaabJtvZw+cJFMrbOb3/ovZRWiviViMWpOdIyYkOnzvFXP4OTqHDoxWcQMiCQZeq+y7HTZ0lmBilUkqy4ISu+j57uwtAdgqDhX6VpDc/zxpZIx5UmQgZE5Rm8ygr/+M1H0Dtv5/RyO8XEdkrOBqqxYVZcA2G1EEQajpmgt389xDpYydt86ENvYvfmHhwFgjrKzrJUgjNnz+E4GmF1mYGODJYMsZdO85b+JLVKjVdefJy2hM25SZ2F5RJutU7W7uLCqVNEQcCz3/0eW3dsJDJ1qtEqDp0qsxjUeeQ7PyCVkCRTUClVWL9uCwDTsxa9/bt55dApqrUiC/OXqZQnmZwe4Wvffgg9mSKey7FSymM6sKo7xwsvPk0Q1fGiEFcphEwgZAIpY4RBA4huGzaqPsJzT3yahDVOR8sKuWSJjOWyPD1GUG1gkEsVwY7dt/OeD/9PeJUCXnGK5fHDiNIFFkZeZfTUs+THj3P8hS/zhf/8u6zLuZx8/DsMmXOIiRdoLR6hpfgsH7rTIFl+hKwekLEkjuUQc1IYukNUr6M0iR8G6JaJNHQiKRC6RhAoqhW3YU6nG9i6gdGAViJQBL5HFPqYmkCXjS63pYdYMiAVE/S2JWlLmeQSFo4e0RLXyCRN0kkTy9YwDImmNxTrpdB/gn754+LT185de7wWaH+Sthn9sDwgVFN4RSFpwMI0AZoUWKbEsXVijolpSDQZEbMtLFM2ygYoNKFQoQ9hiFAhQeDj+x5+UAeipoVKSD3wr2NQha41iar/A+ikqvHbl5tPjeZUwJ3Ag83zXwL+BPg0cH/zGOBbwF8LIYT6WeTX6gwf3hfjy186xNf/fpQHHvwQx89dprc15LmnT8JKFTXRQ4dXgWKAZWUR3iqCQAdvioXpi3zsA2/noe9cxuzYzoXFPHrpMobZQdF3iTlJpl0HW3RgD+7HLZuUvBrxjrWcGR9Ht3O89P3HeOCOrYzO1ijM6gi1kZmLHbzllk0kjCmeHo9jZdupBTaJVBy/WMBnhqWVJbbvHuLY2WcYnbqE5gvelroV4ScZ6BokHrrMHH6ZF0+c58Z9b2Ht2u0YQciVV55i+J1rOOQuUXYD/MI86YSNiPlcGT3FW99+N+nKCG1dm5mafBVDxlG1eTZvCMFdYH4hz3KliN3tk+5J8MLEIl1ugjqdJFqgLnwWlz3MyEbXrAYnmQZWUKkQIwyoGRlEmCcWLjM1O4mW62Q5GsQ1ckg/gjAgkiZYGaTQ0YgQkcvicgkTQTy9nq989QfIaoKMXE++oFPWajj6am5907v5/qOfZ+2qdtbu20h7S5JtKZMj33sINbCD9cMtnB/JE/T/LjvX7yYbTXD2yFWKSyVGxhYIqjlu2fMAX/3eq7gdN1OOLFSrjpu9wpXFE+TjDgPt+3n24EFuvyPOTTd9iLa29ezdexujh7/JurWCqlnizve9ne88eZSqbZMvVdGpEkQF/vmJJaqeQukOSjMQUR3lpVAoQkJM4aP8Esv5eabGH8aSeerFegN7qXSyqX5W/CzK1lgo1kin00SqwmKhRHtHC0tTZ4nbdbzKHNtv2sCB03mOPvV1PvupP2HuygXWduWozk6w+MxD3PeW32TFPY7GGKs4yerEeVZi72Jy6gLJljb0eI5y5OPFUgRBhUg2voC6YUAQUvXqSMtBaODWSrRmE9TKNcJQUgkqpOIpIi2OROGGgnRrBksodOUT+VViuiRpOhhRY/cimz0BrdlgUnhETU57FDVV+UVDuDoMwx/JSq9pBbzRxrlhWcJ1zvy1ca35pFTY7P430QIIDCSyiaxvBGMfw5D4hDgmRGEj+EYheKGH1CVRGGJoEil1hNCoh14Dt4skjPzmewkiKan7HpqmEUQhSjQ4a7/o+LkaUEIITQhxHJgHngJGgLxSKmgumQR6msc9wARA83oB+IkqvhDiY0KII0KII8Vilc7ufh6871fxFgWf+4svsGf1bg4eOM/KzBy16aNceum/sKX9FC3uwwTz/8SRw0/Qu2UzRjZFq5NgvqBxejbLor2foO9e5upZYlErOekgfEWgJyhoq6nF7iIz+IeU297HcnIYY9Uqap5iS/96Xv7uD+gJFtCj16kHko2rP8jFE5OknaO0OiOknCVS8YBqcRZbqxO3U2RbOjlz+jLbt93KH/8fnyAizbeffgHZvZqwo4/LC/PMegEnKnHC3C5O53NMBe2cOH2J5Zk5Tk8WSOdyZFlk/IUvMvr6o9x2+03MKgNPLVN2i1RlRLI7jczU2H/n/bilTi5ejGPY65iezjNzZYm2gXZ8LYZutBGFISY+SS2BFGZjymveQA1gdYw6aKBpPsN97QysXkNmzR4qdoZYOEe3f4a26ByGnCMUILQAW7qYUR5HD4g0QT3Rii738m9/8x3IyhRZsYFkqoLnbMBuWcNvf/z3yZfm2btvO4XqLH/9/WfoWrOFGbOFtk6DS68/jpAJZiZexRDTtKbjpNsE63asJrvhXfzH/zbNRO0+xkmznLQ4Nb6acecWltvewvnqbp4/3Y2z6h6KjkbfgMlTT/8jcbtMXPfY0r8G8hFf+uxncHSHZCyHiAxiuokW1Jmvd7LspqnLRIP2KTwc2yVmlYmbeYS6hMFJsqlL3LJnLzGjgyMvzjF2rs7CVI1vPfRlRiYvgS5wYhaRCjBlyLHDBwiE4sYbt1JcnkD3XYrzS9yzfz+/+4d/xKe//iIvXdR56kxAx+772bZ2mKuXX2Jp/iDZNpejJ6+yXNnN2NQ4HWmfndkC27IFLG+OIBZHj0APIoQfElZd9BDihoWvXAwrIpkwsHSfdFKQSQjabEXcaFgyh0Kn4AnmCkWqKiIyDax4Asux0K5tsQ2JNDQMy0JYGsoUKDyC0EXh/4vWyNeyz2tssR+//uOSgtAUpBbR9UbVNUyslA2tWIlANo0ENdmYUkSN7r7ZyE4bx1rD9lJFDelE0ajl/vD1mm6ozeOGG6vCD4LGPwkpG26mv+D4uRpQqqE4sF0IkQG+A2z4acuajz8NsPUTd6qU+jvg7wB2behVh558jpZslu2b93H00Gt8+s8+xb0f2scTpRG02FpW9W2hOr1IfGmCLTs38MwTF8m2b2KoPUVioM54cSdO2zjnJ+cJMt0oe4CCoUh4lzH9FpQwCXSJFu/mct6BMEsqbuJ6BdqG8nz1sW/TmYDSixf47Y++g++8nGdudjO1pSl0b4FNmTlORgvU8or1Qz2cvvQSyVSZ1pbtTJ4WSJUl8KqMjV0h1FrwSlcxW5PMW/cQs3W80hcZ0foYO5gnVbeJjH4mR2dxx2aort3Oe7e0cvFwxPb3/RHL7jyD+gjxWAbDzXO1WqVjYDex2RF6c6s5P32exIBHyp1E6hmeXjzPvls/xrKeIpA14kGADDSqUiCMKlFkoEU6oR8SuTWk8FnJ2qhqjbRR4q1v3ct/ePoR+sxhgo4lVlWnSLoHaMkk0WfXcSHeS9JJEq+U6KjPMRX4TLYMkSu1cLyq89kvj/AfPvx2PvGZLzBVW4ff0sLY8lV+7fZBHlu8wOLkOcLWbrR1f8xj5VHesfo89dkjFLw61ZmTVOMtqK17OJFPsnHXvTw1Ipk4OUWss5WVaJ52tYb8cpp6KmLUi9gQO8FAa5Uzc3uo+iXSegVVfhW9vkjfppuZyw1waaxMUAn4+Pvu4Jvf/CYtHcMMOWtY0jtxcoOUahA6SWwZ0WJLCisGYVHHsH2cmM/TL/0z9eXzGEGBvr5etq29mQ03v5tKsUK+MEep8CSdnevJxpOoukvd8/HiWfY98DvUx17l0ScfIhWl2HbjNoxgHNuc5/TJUT72W/+eQLRQrZb5wrPf4f5bWtkZy6NHEZeiB3mC9cRyS5Tz7Swvj/Phu9fyD1//Bpme3VRMHTueAFlH1yIcy8BoWhbblo6ugaZcHMdART5ShESynXrdB9eDIGpY7kqD0opLRYLyG2LLiYRGYEp03cQ0BCgPQYBUCktPEamAyI8aCAxDa6jxh4pGygmNvKyhqfgjW/3rLSWJFNe2+j4QImSArlkN1SsBQjQaVBCBD3ozk1SAaGbCkWpkrgh13ZoaEYIhG2v0BgqiVvcxI4t64DXsn4UkQiPSFIbvoglBqAR+GDX0E35Myez/y/jv6uYrpfJCiOeBPUBGCKE3s89eYLq5bBJYBUyKhiF1Glj+Wa+7UsizXCxw8uwZtm7aTN/QIMXlFb7yla/zv//55zh6co6Fq/PELcFv/N7HOHb+EpkuH5eQUyOj9A12siuVRijoyGQoGho+PgQ+6DZK2ICJYSk8z0PTbRwtg6rmycbj4Jfp6N0OYZ3OrMapo0foTW/EIc1yuZWJ6fO09rei5gu0pldxdXyMO267g4OH/plK2WVV7yCj41dZnYZ1aweYXCozvG0LQxv70SbLLM1PYDkBwoyD5RB5Jjve/C6612UZ3nCCVyYm+eRf/DmdfbcxOzPP3Nxltg9n6O4ZIpQFUi1rcb02YuYEjl7m6sURass1kpkql0cO87Zb9lMSUXO7IggjQEVENGBcQFNdXaFpDVvbsK4Rt2yCapXC8gK93Tk06jhRCpspOlM61eIIQx2dSK8dI5jEkcvkpw5jZjeSUBmErGInDaby8xRqC9x+20Zem64y4RuYRppy3WLz9t088egPKMduwBFxBnrTdLSm2JTbxnPPfY2B7T3EM3FE5DE80MPpY0dw+jfTnq2xVJ5mdtmjY7AbDZOa72JqOaQeZ3hwgAvzEY4puHD8DFY8jdR9giCkWCywa9deqq7FydPPsm5jkt4Nqzi5nKC2BF4UUHV9TEdHSo1SMY+pW0grpOK5hLrgzW96N+dPPEZ1aZRKMc+Rwwc49cpJlhcKDK9bS7mq6O7uZmlxnnS6g0o9oOKWiFsmyfY27rx9D8HMJUr5BTZuGSIZX2bPvgxf+toX6V+3m7m5eXraepkvKvKmhRYozo8WiTJpNKnIdHZi1ks88cLLtLT3MudBNawilE8ibuDYBkQeNdclnWwBrYmtFBZaA0WP1KDmNbbcum6iVOO4VqvheaIJVQqxrtM+HaApPC1NlNIg8pGRRHDNjC78FyXrRJO7+q/J2TV+np/IXq+VBwCMpkvqtXnN4E/IpmNAcwrRyGShIf6CEERNURjVtCPRNA0/amj2q0igpAQUSoFt2w0TAvmLA5t+nm5+WzMjRQjhAG8CzgHPAe9pLvsw8N3m8SPN5zSvP/sz66VAEIWseCVW3AKeDMj7ZQq4vOudD/I3n/gkS9Nj3P2Om9G0FT7y4P1Mzk2xcXsbnjbNzn07WYlySD2NE8tQKpXo7WwhJQPMchFfSxJoKQKZwPV8dN3DVPNYXpEerczGVMiNa9dTM9ZQ67mX10bnCSsht6/vpd2ukuvqpBJbR09nkv7EMk44S9yUnD58ip1bb8EyU1wem2Z2qUCutYP+3kEG+tJMT1/k8tWz1MMS5eo8rjtL4NdZ0TOM6V2MaKv47LefZmqxTNKvs6mvjb03bSGWiLNm/Q6WShqZ7kHI6GDdTj16C17SBH2RtNHDcOfNvOf+bSyMP4yYCBCyDMInEg2feCkNDBH9yJ84lY6TzsRpb8+SM2OYQUDKiLh48iUGuhwGukzsqAU79NFK0yTdEYasV7lFO8Bm9RLLxz/P1MVnqBeLWFEHjlGlLn3q6SRfevhztMYnef/2JRLL02gixnhB45Z73sfy+FnWyEn2r51nlT3C7k1dPPTNR9iy426ynTezkncRtQqrWkxWtcaYmRhHll/hps0ae3clqVTPgV1AxOskEylaWjcxO+uT1mrEwgWUsJma9zlzbhIVGSwtzvLiS4/hBov09K/Q3TtGEDzL6uGI3p4USsQxTZPQq9GatMAtIZWPTNSITB2MTqSzlT23/TrK6aWnswvdqKDFJ5GJFcbmrhDPbWJpfp5cOk4xP4shqjgyYHLkHC+89AxXzz3Hqtg8rRnBC8dO88mHD3L66gqz7hwj82c4PXaRtbvuwxj6ABOxt3E18Taqzm7cehvKGGRBwSIOo0Ubu3UjZc/GK9VBaPihwg9CggiE1FjJF6nUAqrViEpNUPF08mXF3JJLpVbH9QLqfkgEhKrpJy9kI6EUDSyp1Ay8uo/nBfh+2JTUi7i20XyjMtNPU1v6cVX7n/WVf6OI8780pBQ/fWrXrjW27deICJahYxkaUeijwhBNKIi8piGiQtKgk0oCbFPHNDQsQ0OTDYoqUfAv3svPO36emmkX8JwQ4iRwGHhKKfV94A+AfyeEuEyjJvqF5vovALnm+X8H/Pt/7Q2EplEpVklZSean5ikUymBaTF5Z5tzxc9y4ZS1f/ewnOHHsRd5x3270pQvMHv8WtUvfI1k6yvZOyZHT56hLhScDLl05Ryxlkcll8Etz6MrF1n2GuyT+/Cu8fRe8c7/HnZvmaHGfwvEOYVtzXJp4ney22/Gd1fxvf/SfOHV1jPkowZlCNy8fPAhzh4kzj8KjJdHCpfNjXLkyw4Zt2wkNg3QuS0dbK9QNTD1Hd/dW2rs2sX7dLQz3biJZHMOqzZCL+UyMncQvzJEzArrjJvWlMY6+8giGVuHqlTEsK81SMc98Ps9y0abidbB1z258q5vHXi0wstjD57/9LHe/62309/eT1aYxo1k0GaEwCEIdQ9ffkFEo+vq7CcIaoaqC55I0JWMXzjA5cpaRs69TWprCFyPU9Fm0WDdbtr2Tqak6o8tfZTZcZstdH2f9XX+NHHwrSy0FnDCGWzKo+hkKKwG1uTniS1e5pb8A3mV0u8KJS0d40/41hMtHeHBfmrR/nli0TDKRYWop4KmXx1ioxrlydZKjrz6HIUNqoUGxYvPiwXNcGl1BGq3UQ5tqoOPVqyyU40zMeGTlLEl/hPn5PFNLHqlMN+VSncCts/vG7azfOszIyCXOnznFxtWrOfjC61wZd1nMpxCagSVD1ve3s7avndAt4wsXM9YQJ6n5CebzJhtvuAf0Fnw06rKIlggJZMSq/o2sHRokGdOYHD1BWJklLM3Sl0vjLV5i19oWulIe45NjTJVCotxmzo7Pk27NMLs0Qa6nnc988RvM6q2cUr2MJreyZKTRTZ8KHspxqJgZSnYfpybr+DJDwraJEAQhKKGB0CnXPPwgoliosrRSYXo+z8T8CkvViJpyWC6UKdc8qvU61bqPF0IoJVIz0A2HCIkXRUjdajRnQoVb86jV6nj1Blb0R76r4kddRK9lfj8tiF5bdy3bvBZE3/jzb1TkeuNrKXwi5REpryEY3ZxwjUnV2GUZpoZp6TiWiS4FlqE1TP4Mg3jMwrEklhZh24KYbWDpCtOQxCwLy9QxdRp8/v8RSvtKqZNKqR1Kqa1Kqc1KqT9rnh9VSt2olFqtlHqvUqrePO82n69uXh/9V98jiMiIFAOJHuRSwP4dt1GZq5BOtWMJjdnRMW7bvYebdt7Enpv2sWP1KjpUyGoz4o6hJCcf/wT1sSf4/Qe38d79WVq1sxQnn2ProODj778J5o7QHozRJ86xf9UMt7cfJ7zySVT+Ic4f/2tqM4/wP9/fwu+/SRGUppmZKrNl134W8jPMTI4w1NrNoWOjrGnX0MQyOAo3iti+eQuJdIK5lUU84TG7NE1ra4KkHUfHYmaujJJxkolWejt6GMw63L4mwU2dNaKrLxOjgmklGLt8jn/7sfezdnWcsDbO+9+5HzOocOOWtRi+SXtrmWz7JDfffAPnxmySPRvRcwO8fkKxOBuyUnyYIeMSHWqShKqiKw3bSeBHP/rnPXv2NEFYI1J1DEPh+TXWrVuDodsEPtSqAe+6Pc2D796G6WQ5fLJIaA3gpnqpJAa4kI8TpvpxEj4JeYa0ZdCVsEnWq6h8hdGL8zz27AXi9bO8Z/8wOW2RzWv6yHUN8uiLp/jy336SsDjH3PQYN9y0E1e5ZHraKNpryUdxBtZtYcmNSKzaRq39vUS976KW2kvdGERoKUxNJ+YoVqo2lbpBpzPP7nU6h18/Qqqzg9deP0ZbrhNN6Jw5f57T589Tj3IknK288NQcTmILNbIE8RSmbZNLOmQdDemXiWkKLUg2qIWyiBfN4OMjZBut/TcxW0xQrOToaF9HNtVCf2+ckYsXCOtF9t+6E7c4SVhexPQr7B9O8Ie/95uMzi1xbrLIi6+dY2q6SC7VgqxKtKogazsMDab54t9/jiWR4GqUoK5pSFHGlyGWUhhaAk+241ttBLpDGFXxAoXnh5SqNaquRzyRQrMcTEfD9SsoQxAIHU/q+JpJiKBSc6l5PjXPx/UatshK6AjTxDBjWE4SLwipuyG+31COCoNmOTT6yRDxRgeAN2q6as2t+fXg8t+hsfqT44fsKU0TGIbWoMJq0XUpQdGsszaoqGBK0KXA1BtwqWTcIOmYGLpARgEafpNGqtBQ6DSaVToK/RePpb8cdFIVguWa3L33bbx5912cfOkk3rLP9NQM/+ajH+PY4SMsTC9SLrpcvbLApclF1q+/hV/50O9y7NAR3v3OW9mVm2fywGdorx/j4+/dxN41EM29xrGnv8Zvve9ONvWY6Plz7N8cw8m/zOy5J+nvMnjfu97M1nVd+KMvs54xcvUr3LVjE8vTk3QlFZMnn6XTmyfV0kdXLo3CJUAREHL06GFasmmqXplMe4rW9jSeX2ZxfoTLoyfo7s9RcVe4PHqCWDwg0GK88PRjzI+epCdnEUqT3OobGFqzmoHhbt7zrru4/+37mL56loQRIutFKnNFEvF5pDiJ9FxOvXyeuB5iiQq9qTVYriBjvsbC+ecZzClEvQBK4bpeYx90vR+orsuh2bYJekCpUuT/5e7Ng+O+zzPPz+/uuxvdABr3TQAEeIu3RFKkbsmSLMW2LDuOr8SO4yTOsXFNMpldeXa8zjiOc9jJeGzZsTWWZcvWYUqyJIqUSIn3fYAgcd9AA90A+j5+5/zRIKV4d2t3x9ktZ79VqG4UgAaqgHrxft/3eT6P5vKwkEhiGBKVlU3Y41dIjpwnpJh89IMP43YX8BTX43G8BN1zlJaewRx/gQ3kmY9fRyOOz57FzM4xNT2Nt76bAz/fz1s/f5GLh9/m5R+/TL5YRfeWj5KILXPHvnsIVoRIJOepbapCclmYvkYmE1kCNXVMJzJMpQ1icjsptZWsWktRcoGkI0spbDuPKSg4yHiULOt7q1lOJyjYJbx+H2fOnGF6YprJiWmOHj3JxOwCilaDrDQQW8iQs/OknBiGYeBxKfg0mfRiHE1VkCwPkg2CmMJiFre7XNC8VW0Irgay2RCO5WfDug0k5gepikSYm53ENvP4PSpuWUByLD60ZwsHX3uVkVgayxWmZ+1m/KoHryRTWCpR7YmSmo1RzE3z+G98BMt0E6paBbYbxRZx0FAMAxkBE7mM+BMlBMVAWrGJOo5AUS/hiAKqqpZjlxQRRZNBEbBEm5KtIysqoixREa4kEKxAVtVyB4qDZdoU9RKmbZErFFZm6hIul3sFxCz/767iv9xB/nI0ynvP/zk8+//OebeYlvff/5KmLwjCCrVqZW4qlH92VZZuFlRRAEWRUKQbf/tlNYuEsGJ5df7F81/1/FpEPX/3G3//xBcffZiAv4bh/hE2dq3h9s3beO7QAYSSSXtdI5u2bEAWTArFFLdsvJXpxAzh2ii+ynpOvH2dWk8zRw68wa3rVqEv91FKXuK+h9fT6nE4f/IQMzMxRFtAMEuEAwYLhQWWhM389M05LNx4UxMIw5dY1xXg7OgpGjtUloZe5/69HXSsDdPqW+Ls4CU6KmtwFrNkK7eRs3Riixlq/V4e31gL8dOMpIcw04t84PbttDbUMiFKXJkao8K2sVseJKiAS8+RjI2SXprhzPFDfPPvf5+x+ThP/vR1VHc96YzFyNQyD2yLMZmep7BQgZC5wPpVBt853UlFQGLk2gnq1t1CzirQIQ8Tc7cRjVTh8UQZXJapb21DSF0DQyIogWkKyKEWNMfBm5mntJymp8bF6Td+QX11O0uJEqJhcWwsiKPVU1kT4Pr1o+gL18jF+7i9t4OPffQDXP3Fs3SFZ7ml+hI9kQo6vDM8dEcXkktFdzykFk1uffRxMok1zI8b3Pm+Lvb3x9CbP87S7Dya2c83v/0NKtc9Qv+oFyEbwpCgsdqku7aT5KKLXKgdxZinIFZgOz66nDih5AzLxWYWBS9ixKaQdnH96DO01ifJzZtUhx9g9PJh0oszWE497vo7mcyEkUKrSY+PM5z2Mlezl3ldxe/kiIgOeraE1tDChUkRM5fHjFQgehQW0iP0X/42hdGfscadJmTECZKlo72BnnVrePPwAcLVfqR4gpqqFL1dDbz4o7e4c1cPDz4Q4eqJN3n6pTc5MZxGV7zotsrY6ByGVcLvFPCIBrmShVrdjc/dTKhxHRlDQ3bAa+ZQLBNDtbAdActWsFGwBRFBlsi4LAJujZmxCdwuDwXboqhJOJKHYtqgyhtG0nX0TJJw0I2hmAgoqJKrjO45rYTtAAAgAElEQVQzS8g+L4ZhopcKaFh4JAe3UKZB2baBY1vIokTZjl9OWi13hEYZZ2cJOAYIko21oic1Vx5vSIzee+W/4eMv7/bNFV1p+X2hvGgvv608F0UBwRYQBBFxpSEQBBFBENFQkUQFSVDKow4kEMSbRRXHKl/bJZBlH5YprKhWZRRUJFvGELIrfYaDLZSDiQzT4vjL3/iVop5/Lbz5uXyBlw8cIFpZRXtrA0pQ4OjpN2is0mipC7Lh9h28+PQPePg3HiFVynDiZFm289T3fkRVuJ4LZ/sZyF/hc1/4LH5vBU52gW3tGzCuTXG9/yLp2DKf+/yfce7cO5w5/BrFWZtC+IMMTbYSbNxMWpllvDBJZuYildkYm3c9QiqbRowYdASKFJYH6L8+xczyEj7vLPVV9YwuTxDyVuMVMghWnGJ6mti182STBeaXklwejeFVl5gXfeSyAqK7mni+SJVLIT6zQDq7TG1FgJq6TfzHL/4HsobJxz/75yxaJinboqgXMGQ/iVSJTEGnqbUNWQkTCm4kn+3HMKooFsNUR0MkJo7xkftrOHv6Hdpb65j1KxhLY9QGPMwWvZTyGdzuAMlUHLewRDQIqYVrZOM+dt/WgkqR2FwGf1UFj921k8mxGMfPz1MT7KShvY3OHQv8+GcH+Kt//DGbN23B7Xjo2XIbC8njWKVO4tdiFKcK7NvSRkNHhisTFuniFLff2Uv3+jzR2SlGp1I0RyIsJ7IEwxsYW6hCre0iuaQieDTm4lnGvbM0tGgMzs+QciowhQyyFMcdGKa2WSQbX6Qy7sdYWqRCCVJyZXHbIi6nQNo+S+vmKpJLKZT6bUzJGyi2VJP3uPjkxz/BhXNHSC4kqA11kEyJWB4ZZeE67qUALfIYlpbGnRsjW5RwWzq5khtNd+GRXfzJx/bx05+9yGx8mQZXji88dg+XLvejhruoW9XM8FyJ93/wMa6eeY7RMxcJuOpxB1pwuxxWr97B5s07ee0Xh8jMzxDyRBgeukaksZOqUAu+iiCmYIEsYpZMLBEEWUMW7DIlXljxtjs2omPjZHJoAQkjmSBcE6FoFVFsGZdksJSaoeQBRAHN6yNT0BFEBVXxUCyUi6Tj2JRyRSTRRrRBdrlwJImSbmCUTILBIKZlk80VUGQZv+wtb9Lt8utauokqqMiqgmG8i917V8cs3iyi/xohdf9Pz41uGcA0i9iOgQNIslhGGAo2CgpQLvzlMEIRTfvVvfm/Fp3p3/31Xz3RGdQ4efYkb504x4d/5x6SxTm6WyNMjg8wO3wNC4uB0WGi9VGyySWuXrhKT+ct6GmHNR1beOy3P47mcpHP61iWiDdYxYWTZzj95gFqq93MxM4Tm71KR2MD+/Z9kOFMPcl8E4q7gcpKaGlIkUheQbElFtJLrG4Os6m3GcEsMTWfICusQlH9CMYiLpeApdaRKdTgllJs7lHwpA9SqSaJVHUyMz+NFNlGLryHnBxloH+U7qZuMuEmPCxi5sYJu9IsLExT39zK7dt3MnSxjyunz+H2RujduJX5ZJauVSJnzvWTXFa576HbGZ9a4PLsHoRiingsjhzpYbkEPmEJT+4gmYUZRqeTGP52ckUwSzYFBHySgICDYxYIOjOsjRrs21hHen6Q6bHLeDyQWJ7BosRoPM+Gje+nd90OLl9PUb+6neGr+xER2LhhDd0dTbS2NfPOsTPgWc/Zcxe5cOVFfuODuylZNmfOZNm7o5XY/AC3727kG//5T3CKFYTUTjpbsrz+8/00997PjLKBeakGM1xD0VJwjG4S84dYt0lhcGCGVKAbzYzgL9YRNWspLE7x4P0tVIwd5XMfv40qzYPPHmH3rmaGRrNEqt3E4lMkCjKlyr3Mebay5G3H56ln5OxP+PQH1mIicH08S8m9FlW/xK2ePj66RSHqDFMXSLFOO8ktdQEi2OTji/gVk0un36HWvYienefFZ57i2oVzGLkc02OT5Lz1pAmwkBGoqfCgjx2mNHqCuKuWM5f6SeaK2IKCy+1mYnoCI1vg4fvv4fz5i0guL47sRQyECDc0UzANPIqJLJYoSQqyUA5yFCj7zcuWS4vhy0dYFVXIzl3lwjvPEQ07JGaucv7EIR59YA9L8xPYksixs2dQvAEoaThWuZMTJQFBdiiaFrZjY1oWoiQhCCIl08a2JRxRRJJVHFvEdBxUzY0oiYhiORLath3KikcZSXRwBAFRVCkZFo4tYhgm0goJ6l948W8WVqesJf2/uFYLv2SVv3m1RyyDrxFuPsK7wyx4T0EVjXLCqVierYoSgAWShCiWgSi2I2LbZVLWkRf/9lfqTH89ZqY2aG4vu/bu43d+/0MMjw/RtaGHptZ6WlqbqKmpprGxke7uThzHob4uQnfXKvScztxkjJa6BiYXptBVGcHvx/H4uNh3mdfeeYvHHvw4QkHklq413LVjL5u6trH/+wfZs1GiUuonaPQRluYY6zvP6pZVhNq6uTI8QTJXYjaWwnTXMrQooatN+EKrMPQ06aVr6MvDqKqLqsoAbqlIR1MAPb9IKBgkmyvx6rErzOb9pDMGQa8Ptz+ELEMqGcOlmLjdEul8kXjGZni6wO/92V/jjrQTitTx/Sf/C6qQw+fx4lYCjI2N4fZ7GZjIk7eKKG4BxStgKSa64iJWUrg+L2F6m9HlIAUUTM1HBg1VKOHoWVrro4TcEm0Nfla1Brjw1n7CisWm7k5qKiKk42lam7rwiLUcPniWxSVI5uY5e+kVPnT/bdT6Dda3B6irEFjT2UlNdTuvX6gnqd1C8/rNvHnhApcnC3gaH+PogdfweWyCNRUojsS25io2hpbRPAXuuX8PnlAAWxPRFYOkk8aQNQpSLYI3yqWrfTSGbUxTQijO4zXHKKYmEIpuBg/N0FRh0H/xMKNTY4Qa2zHclUzlJFLDBdLTFq3VPUQ8EaqCKj5XBvfcFVpCKk/+w5eY7DtCbYWMo6mErBnWVRUR585gz52n2W9Q45mhkLiI25qjIaLgU0t0dIS5MDDOpaExFjMgaC5qWzrZcvu91DREcMkKpfQSyfmr1FSpSILEbHoGS8rhDzgkl0eYmLxId081/pBNU2cES85i2HEghkvOU+GzMbJTqM4iXrVIqbhEOrmEJDiI2CiScPP5nlvXcub4ftxKHKN4nUziLEN9LxMbvch/+85XyWcmefbpbyMLOrJg41JUUkvLGLaFYTvo5gp0xAJZ1SgjpmV0R8GRVHRLwnBkSpaAYQgYtnhTBG9aDqIsA+U7uWU570qoHHElfFC8aS+90aXeCPD7Hz3vjWZ+bzzze99ufL8b81nHcVaioUGUyskAjmMhySKKoryrZ1WUmwqDX/X8WnSmf/uVrzzx2K3b2H37XmRFYC4+S2J5iUhDE55AFbmCQSqVI5FYQlU0isUlzAL0tK1hfXcvTjHL4PQwYyOjSJKMO+CndX0Puz/8EJ6ci46u1YiOxtsHTvPCD1/hyskB1jQskBy7wvZ1QWqCCcRMnJBSzdOvvUNjay8uVHwV7Ry6nCSm9GB51nP16hDjg8/j9+fJGzVYVdso5aZwssM0yVOUUjP86KXXsAomXXf+KaN6J9GQxuCFg7S1VGNJPuLXDmEvXScbHyMU7USraOfgkX5y/l6Cq+/h7779PT72+CMohQk66g3OH79CZ9cW+scvc+B4AiOyGTM3SCYzi1rbi+6pI+iVSZRqEX29iBWrWbAq0UU3pl4kIi4hFXPUVlZhYZCcPUtAmmVdjcNA31lK2TS3bd3JYmwBPZ2nqeceGmv8TAwe4H176zDiR5Ay4+zc1MVQ/1n6rg9yaSzH5WmFmepNKK56cokQLu9aBuMWhaogftnF6akiB45cp7uuhxrN5o1X/omWnfuQzRRT8zHScpC6phY8skpaFyiJPmQriZleZt+O1VyarKPdd4CPPzJBJv/3FLNJKpINLMwfwgz5GIq52LptLQtLw8zPuzmy/xiOINPSth6bIMX8MkJhlN6gi9jSDLWVPmqCHmLxJWxVJZzto14tkDY89MdV+uJu+q6dQ6vaxPa7P4wrHOTYsQNYuSI92+7k8Dsn+cM//By27OXeRz/Mf/rmt7lw+W3Cgki1kOQPPrmDq32nuDQYZ7qUIZtKIVvmCunIYHlxhrXr27CtNNOzw3R0NVLXWMGrP/sJ3atbMXLzpCYv8fzT3yIUqQCCVIQqUGStPEvEQpJAwiI2dQ1VyDLYf4LZ2XHyxTyrO7vYvqWHV15+lpm5KR77wAdZTiwSCPhxuVyYK1d1c4WEL4gikqQgKRrZfAnTERGQyRcMbFtAN8vaVN1wsKw8omCXFziCCIKMbZdZo7YjAtLK6ypIklzOpeJdaZR4w8MJ/I92pjeOiIggSji/1Jm+dz57U8cqlees5dDnsl8fRyCv65imhXNDZuaUX/ntn//dv/2ZqUvTiEailLIlvvPtp1jKxfH6wIy8RnK6wOd/6yHWrV7L8PAAfReuctvuXhRfBX63ylJsnrmJcXZ39FAwwR1t4fUXniPcUsktt60l7QiMDkzi0vz887d+zDf/7suUsmmagx1E1y4jyibHL7zJ7l13YRcquGtrirnZJQq2g795C7XVUeL5GqbSfrpvuZf+5Pco6nGqqjTG5AyKIKKoAVQpjOmIrFrXQno0S0yX8Ve1oHCNCk+RhcR1PFYFTnIOWGRybIxP/vHv8sP9p1m396OMyasR5Dru+vi/Y/9r32N9cI7IPbfjJJd57HMP8eTLT1LTsoUlT4j8Inj81dhCmLxRT9YpIfpWkyzGiAbdaIU8jj6Ly0zRVl/FhWMDaJ09lHIZpmfHaQuJ+KXjqNocO3Y8wLM//CqBYC0ebwUzc29THVK4a3Mllw8/RavL5MCx00zE42zaupP+N/uxIxvI+drxKHcgOKe4930VeFw6xmmd6XmRMXsNuZo9WJk8pdkTdHSUiK4O4vFtJpkfI+CS2bW2l7dPjyAr9QgRF4ZrBstqwtFLTE6MENRUmqQwIy8v0Vjx+yTyR9i++zx2djOHxobZ2Hsvz37/W0RDw/isXsLbKmntaGMytQDFKPXRGqYvXub86lbS3l0EI8t0eIf5RHcVZ2aucHjC5lpFG3PzURbd9WTFSk4dPcUutY0BO87S4hQlq5JbezfjUTxEfD6e++E/s5zN03etj87ODvoGJnnnJ//AmTee542ffJn9bx6nce3jBGdGGF6IEdZ8lEpFJK9KtLGeXFbnpbOHyBdsxifnqLcVAmKO4bMvEV8u4hFM7tnaQcFeoK31fvK5Al6PC1Esu3YE0cYR13LbLj+aPUPEH2V8apL6xjbOnn2D8XEZr2awqjHEj7//DUKRNi67LnPHXY+C48WybBxJxrHLcdGWI2ALCqaooCgaul4qF9eijoyNLErkSyZe1QLJhe0IGHY5iM+wTATbwrLLMBJJUlY6RwFFVVZcVzKmaaLr+v+hx/xf+7wXsCJJUhlwbZlYVlk/a9tgmja2Y2MYBqYFpqOUI17+Fea7vxad6Te//ldPfOoDt/KTV56nKIq0NfcwfC3GH37y83z88Qfp6qrj6rUzHDv6Nm6XhuPy8P3vPI8qhJidjLNx3QYMWyaemGPo3Akaa0L07tjJpcNnuHrsMmYuTzjiYv3GDmanJ1i7qgfLTuEJ+1F9FTREe3CpQZ575ine99BeetrWE6qqYnh6jLmpcUZPniQa1HCljzB69SwtbVuwhSyJokNA6sTUF/Eob5AajRNSFTJGEEFrZtmMgMdF37m3+Z/ev4UNzQbnT75AJjuPqIpsXd9DbqafSNU9zAUrSEk1aFmJgCpQ1xak3esQlKcpKj6ePbCMp+4xTCHCwPhLGIKHyood+NXTeNIXEOy1tFedJyQ9j0vIUyHLbFvXxNaGC5yanGKsJFNf08BXPrOadtdBujcpNDU38dwvhhgcKWAYST716Z3s3upCMWbIL4xTWJxELS2zedNazhw6hGhY2K4WLmdWMV9xN6nKNxDHU3z6NofxwbeITXkRxTw1gsx4SsWluai1RmkJCMwkXFRuaePyD5/Dv+33mUz1c+taD4vZZVJmB15pipTuR9dqmR85yOP3aRw5U0MiejdH0vMEg3u4enmGwbkYbXWtDB3/Id3VElF3JWN9Z2kULFzBEoX8LBom6WIRpS6CWgrRFQmxODbM2MBp7r+9neLIT9nUs5dr4noG0iUUtYRHdNPRs4ZieBVzSh0F3ypu6erCk7zGC0//jKVYms987rdYvTaAVYoxd/k61nycL/7Zg+TsOf7+ez9n022fxRbrGbx6gNv33Icp+IktxXHkIiVzgWioBjHsxczmqA9EyBd0MqqLbDrJ0vwskZouBhN+7nrkTyhYOcKVKjMzF3G7DEy9SHW0mdhimlDYi9vn4sCh14nURKhpqMMRx7l2/RqJhI4a6KS9Zw/7Hvokra0bKRU1SoaAJUrl/CZHRFHU8qbcKCKYOpJRRBJFJBEMo4QggyCDpEnoko69osxUcCHaIpqkYoZd+AIammrhdYloLgVFk9Hk8ozexsAWrHIEsyOvdI0rHn4kcKQVnei7WtQbIBXZLvv+RRxkUSyj+IQyYcqxjXLEtW0jWBaCaWKKK7pYR8BBwnEkZFsGBxzLwjBNDFMB0QeijGE4ZSylICE6AhIih/f/ap3pr0Ux/cGT33qiiiWu9F9iPp5gcGCKcMjBH1ZYt6kTrcrH9SuXUFSN6tpaOrs6GeyfYGkxi6yqjE9P0Nm9BkESaW1vo1AoMDMywdp1m1nV2owk2wwMX8GjiOy+7x4WR8fL7ETNVR6ge1SWM3G23nc3p945QEv3BtKJGWYXhrn1th288tJL1EXy3LOtgfqgi+mhCTxyFZN6kKCnnZA7j5o9jJy3QBFYSjvEipXYlRswhSLpuT4q7Djp9BCx2Qlcqko2tUg6Pcu6tc3oSpCE5iGv+/HlDBpCGkNXz7F3S4igv4pXTi9T9PUiRNZRXFwk5B5H1g2Cvi4UeZ4qycIizvzET3FLC+h2Aw61FDMy3/7+D2jZ8mFQu/GqVVw8/DSb10XRzHmKusapU2N43WFKxQS33drLgV/8V65dO4deTHDp4lF27FxFLJalLhomsRhnuagiVW4gY1dSWnKzJVpLemo/Q2NxEJpobrWp8OSZzplgF+nyZbGS18Bt4HjCrPIGOZ2JMLs4x8iFkwR8ESR/LQZelm0XgqLT4MnRmBoEM8ZycgAhsIq5ZZOmjihhzWZyZormlhriiQWm5hPkLYlpU8XQunFpddy2ugoxPcLta3ppbA4yef0YDdU2LnGOYEAnnZthwd7IiQGRoBZCy6UQFxdI2V4E0UUxk0UtpXHiY8yPD/H2+aOULJnDbx9jMTHGPffcyZru1dTViHT39HDp8hCHTw2zbudd/OTn+1GtFF6PRjI1jyRaLMQSFLIldENEC3pw8iWGB8epa20iPpPD462jZ9M9FJUmglW91Na24w0ojI0OcfnSBdrbV+Mgk0kVqAybqMxQHdR55qm/QXayxBcmmLjeT1tjF1u23sHm7feheKooWgoBfwjdctD1cpGyKYNCBAGkG1dup1ywZEFFkkRkqXxhVWQFHAfTEhDscuFRZRnH0pFlETQLtyKiieXPlRUVy3aQHbuMMnTsclF1HAT7XQ3qe7tA4b2LNlY8+ys0U4d3dVNOmQuFjb1ihxWwnHK3adkOJuXl2E3PPgK2Q3m8K4tlbbgj4QgyjmBhWiYglZGC5cwAjvz/oZh+6d9/8Qm/PsknPvFhvvjvfo+5uYv89mc+zJ4Ht3L4+AFaWuq4PjhIIBLB7fUz0HeRnTvvpLt3E28eP0F9ZwtDEzM887Ofki2VqIzUUlvbxvx8Gpk0xcIyFR6J9MIMF948yNTQdTKZApGaWrJWCTmogU9C88s4BZXSosXCzCSdbZUk5sf5xG89zrZOF6ffeB6XI/DQvQ9x+cIQA3Mpepq34BWX6W2Mk55dRgv6SWZ0pjJ+1IbtWGKB3MI13PkJLH2c+akUfrUSTXJRLEzh9WbI2C5K3g5EsQp/KUZYTXH37RtprC/yyuvXOT/XiNy4l5jtJSqqLC8ex+vx4vavx9HySLqDLS/RVh+gvmk1cs0eLo2Y2LRiRHrJyG3YWj0ibuan+2hsq8UnmSwu5pibWGB0YAS/V2R5aZJKIqzp3EC4ogYcBZsART2LW7bQi1kaGruYWXbhKLW4l5oJy8cZGfwJbtdmolVtiMYBNHuEVbfcSS6eYntzmKvnX2XJTFFT2c0bLzyPtO2T6Gh4S2l+8wOPcOniYYrCRpb9LmxXFo+u4r06zKc/VWBDr8PI5C3M2zk0VwpleYxccg4jM4tACcXlYjqe5rpaT7Dmd6mObKQ1co3M9AnyMYeJ9BV8UoKoO0N3jcSJQ8/RVR/h4oxFOLqX0YtD7OhuIiikCK65jTf2P0u93ySkT7GuPcKm7Zs5M3mekakUHlc1G9a2MXT9PG45w747t/LKayd54ZWz+GvXIVSEGI+PYCwuo7p1UtkpBCQ0JYRoV5LKl0gVUsimSdDnJydprGvaiOVqYs3u36Rqzfuoa+4i6BJwu/Joqoak+RElLxXhai6cu4CdO8vE9YNcPPEicmGWxekJNNtGLsmMjcaZXxLwVXfT0rkZW/RTNLLgiLjcXlSt7F93a+UEUgEbVZHRZAmPW8Ot+JAlCU1Ryn51x0FTVRw7hGOBaVookgkUUWSbUMhNQJXQJNAUGVEWUDQZwbIwTZ0yQYQV5t27S6MbHv8by6IbGtJ34SXl2ayDgCit5Em/F6Ky0t0Kwg2NqVRuW7nBWwUQ0HEwBbu8fHNsSpaAboFpmeiGXbYE2MINyB/v7P/Vtvm/FsX0v/7T3z0RsfN84rc+yA/++btUVVZQXVPFxcFLaKqXp3/4UyanYnSuWk1DQxNNNUGmp5ZYu2Enk9NzSC6FomXy0Y99lFwhx5mz53jr2ClSBROPT6FQyNPWVE/Y72dkaBi/z8/tD76fr33tq7xz+hR1rQ1UVod46efP8/aLfXzjKz9g3847eOfwIWorG9BzNoGKVYTCLazetAU8MklzFscsEPU34WKRgNCHkYGSIpJIZFEqN1H0r2F2YQozOU5HyGbo6jBtjZuwdA+2CfX1lVRXh/FF76akbKeYN2nwnGNLb5rGmjn8CrzxxlWUxntYUurIq35ky8dc8hKCO4Lh30ZKFHCEKkzPDhKpBqazDVzJ+Sn5m8iLIUxXANwitlBCsAtU1nk4O9DHhWODnD19hqCmMjs+g8fnwx3wU9vQxOX+U+T1eT76e59geGyQrlWrGLjex5133sHQVIpYsZqi2kIkkEXmO+zcECS5GCFbSHPxzHGW0yrTmWY0uYrHdm/hrVeexxWKEptLY6WHiNfvBbkWj+hw5NRxPnDfJtL5IIu2gSHqyKYfQ+lgdOIHVPscrl73EAzpbAtNsr5OwlWaosGTISDrDPT3Y5gyFav3YTm9LGZzbN5Tz3TJRzp4F0nHYOum7URVGXc+zeSlfuo8YS6NnKJg17J6bS+J9BQJwWEyk6K2WuGN/d9lYfRtYlNnSS0PMZcYYefm22isqmJu+jx/8kefZtP6Xr77g+c5eXGO1p7d1KzaRN/AALpZwCiUAwNllwvVXcm+Ox/l9NkBahuiPPLBh5kaGcfjjTC0UGLw0jW6d91H07odEAgSDFlMj73DkVdfprauEbe/HkmpwLSgPlpFfmGcwUtnSEyP4uSKlLIisYk8mqYxOZfhG/+8n6zlp2ipZT6Dx0FWNCzDBtvEsQ0EARRFRhRAW8mHcrs0ZEnGcQxsW0cULWRZwDJLqJIHTbHRs4us7qijrTFEXdSLIjj4XSIeTcRyDBxsBEVEMEsrG/cy0q+84X8XmHLj8UYSq+OAJMk4DjcLIQhl2+tKd3qjMy1/WAJBQhCUcjEVZRDLRbQsebKxLRtHFMsAQMcus0tXkletGzlUgoRdRkYBAu/s//q//WL6vz7x75+4e2MNA1cGuXrhOnOzSSqrm1lILCE7IZqinWiij9HBMVRZweXWCVc0kktZ9F28iktQCFV7qajwUVsbJb68yLnr1xmei3HonVPotkgmlcbjDdDQ0o67ooqBSxfZeftuHn7k/dSuamfiyiX0VJLummY+9MBjdHW007W6mem5BXIlB2+4Gl9FJblSCZdLwDYWiMfO85sf/CzoMebHX0emAiFQwfzsMrFCDUL1dmzRIT52iVafw9JSHiQbd8ChslYlWh8hkUjiRDeRtNbhFPOsrrzE6de/yvvftwEnVeSVVw8ynFOItK1Dd/z4DYnR4ZeJ1tQhutehyyaK6Scti5iWH12qoOCWMGUbxRTKYmprEcnMUOmPsJy3iOclpFI1kYALn1Mi5IugCxq2y8+M7MaQ08hKnkJ2kdOnzjI+ucCdd+3lZy+8TNKqoBi5jax/IxljjsbQED2+CJcunGYmcx1P+AHk2keZF1tBcCiMvcnM4ClyRYHmro3cuVFhyK4jZdQiqCrFaAOLV95CNacAH45diaVJ5EJhtJiOPpHAX6+gWy6k0YOEozY+JU8pNYNuiMwmLHJSPS6tk1XrIiiuCe7ctZXDx8fp3fk+Tv3iKVIzU6RTGRZyKjVr70So38manfcwo1dTsjKMjfWheGsoSWHcngCSO8DwYD+l+BDDJ0/xpS88zrmDr7Jreyv/21f+gB898xTP/PhNro2IVLauYzqZRXT7KeR07LzIuu23spgSiMUlljIwk0hQ2VDJQw/ex1tvv0ZsbBZZquCPvvQt1j/wKRpXbSGf1VGMDKKVYD4xQKWmkcnZBKKrMQU3lmHi1cCjuYjFhtm4aTUz06N0dGxg05Zd3HrfrXRu241c0YzorcY0BVyai6yVQnQkVEXBpWmoYnl55FZkcGw8qlS20koismQBOrJsI8s2qgput4RipfFIReqq3LQ3Bgh7Bdyyg0eTcCsismAgKQKyqpQ7RMNYGRWISKKMaddCOx4AACAASURBVJYXU++NLbkJi6ZsW12ZNnCjM3UcsB1wEBBu2qKFlZnojbnoymM5mOXm14piWTsr2QISIDoOju0g2DKiI2OKAqbtYFncHBk4iBzd/zf/9rf5oihiGg75bAmzBAuJAq++8jYz8QUaG6IU0kVEwaC+PowiKSwuzzM9NMvrL51h5/bd6Nk8yeUCpWIdJSvD7jv2UNvVw5NPPcvHP/IFsvFZspl5XnrtTfbt20trdxeNtVGWisUyLDdfwsrlWN3cRmxgmItnp2jq+DBYBhu3rMOSvGi+Ao5V3lza2QJh0UNLncTT//x1Dh15g/v3ytSGW0ikc8RicXyrghQFFY/bT21NI1f7XqJkZghVw+jMMJtu6cRRJDLFDLoZQ7dyeDUZK5fijz/3ecyFFCcPH8Ml51iYH6TOSqIINajFJcjGiagmBSeP5ehoyBS0cVQ7jCT6yJNEcsCPQEkIICEhOzA3uQBuH/Utu5G4Rmb+Kq6SxdJSlkhjM1UtjSz77uTKO9/lkdtXMdo/hcu+laraFCfPniNUHWXtngd59rKXtKUgS83ohQZe/uHLKJU6tpxkakkmWt9FSZGJZa+SUseJVMrMprJIikpLrR8uzyEqa8lZXpY0CWcmwRc/v41nDuYoWS7SapYlfRLFWE0mMcJdH23nhaMakquKt86coqchzJ49+zhw8BKLxQyNm3ZRXbmFxewFPNoy1nIXHcEAJ19+ks8+uJXVPT3MZXSee+sKJ8eK1K2qYvxkP1SsJaRm8EgiWqaI4gqRLxkUnVp8lWtoEBX+5PMf4f57d/PwvfeRXp7kn/7hP5FIZLlwcYGKxu0sZ2yKto3qkrj3jvt47pmfky6YfO4P/gP9VyZALCBrBd459jpPPf19dty6DiFlUMxrZPICeXcbxaVFagIRwh6HIgZHDh/HlUzyF1/+Nv1zEpKgonhEVDmHp7aOL3zxj/nWP/wFu+/axcRwnE0717P/yH7CDRupLhXJ5ZbwqEEcXccWTAwMRGQkUQZFRBM1ZFlCWlGZC4KAY5voeh5FkfH63LjdGoZRwjB1Qj4NFZPe7jpcIqjYyI6NLckoMmBLiLKEYENJL0c5O4hYDtiWjCJaGOK7etH3+vgtkxWdZ9kff4OJIsrlIvfLJCpJkSlnmYhlnatV5pxKsvOuDEoQy6XXdiiPTUVEWaJoiVimheTWkGzKWllzBVP5ryA3+LXoTP/8z//nJx66fRfdq8MgT5ErKCzF61AVAb8WIp/N43G52L75VsZHZ2hYX0dOyLGqewsjo7MMDV3htm1bWN3ZCbaDqrpIpzP85EdvsqrJS21jI3nJzcHj5zl24SLZbAqv20dFtJrxqUmcUpHm6gYKiSyO6GHH5i3MjwwxOTLChXOnURUdX1UUw+ujkMrh81aQSadZlty8duBZtm7eQLhyEyOzcVxulcXxOE1d6yipXnwujTXNVQyffgN/WGDPzjvp7thMf98kyVyR+tZmLg/3sap6LTWBRZobrtPTG4bFFN9/8XUUNhNVLKTCPEb9Pbj9l5kbNWip3YWhuinJPhxRwhJ8mJKCLjpgyoi2hikLWIKBaecJBCO0RptQspOEnSk2NpoMFtwQiDI9McF41o/R/hgzVjseTzejJZWU5z5CjeuZSfSzbe2nCVfX8ePDP0VTt7OrPYMneRW3y0fRWsJbXMRTKLNSl/1VFGWRLjlBem6WtnU7qV84hGEvUgrUMrrsJS2vwrAVwlYGtbKZyye+w57uJtLzi0yZPtxqHVrYi+VzcfrZv+U31qdR7QJKoAOXYLC2s5ODR+fQ/etovesxxocXuX9fJzVek/pImEOvvMa2NW3MXXmVAyeWmGMXZvU+MlQxmyxg1W+nUrXI6n4Ib8KQg6zrDbCcCWJJtfSur+Zrf3oHW+uqOHLmOF/+z1/lVP8Erx0dY6noZzSxDB43mdQ8TbVhrlw8x6o1PcwkE6SdRlq6txCtb6a9uZrJgcuUlmfJM8v8bIJtvatZ29XN+lsewJEL1IZkkvFRvv+9b7Fl0zaa6laz/o77SWZMRAO8gkFIA02yMU2byYkjXO97m4WpcRobKjj41n9jMTdClaeZlmgLostkPjNLChtNCSPYIDoGgmMi2TaGqKN5VGRFwBFMbKuEI5iUhCAuTaSnNUht0KEp6ida4WVNJAiFPNEKDx7NRtMkRElEkx00l4CNiGEJSAjYhoEkaJgm5ZmpULZtFszcyiigHBOialo5IcCxynVsZdZZ1pBKOHZhZTlm31xQCZSNAiCVqfpIZdizI2AJIoagYovlCBOVEhYaoqRgCRI6YAomBTuHredQZAHHssvefAEEReLoC1/7t9+ZKorAk0+9yvf+6XHaO29nc8LN1/76FWwzgmqJmK4gJ65MkDSOUlNdTf7wOTpamxgeGSXoD7HxvofZsXUvbxw8yPT0LH3XB1BUNzu3rGI5MUVLSwNuTUSSBTZvuJV9+/ZRWprH46lkYqKPNw4e4Y5du2lpaKSKEkNXRkgvpmjvaqN39TqKVp65kWHMYJDZq8NI2SJaQCHSVMWX/vJL9F8Z4cSpPvzRaubzJnlTZ3bwKI99dh+GlSefWuJnS2P0brybnJ5mfGKIqsYQ1ZWNFAuwPFnA1VWgQlnglu5aSGb57ree5mO/8xccPzhFOFTi7f4reMxzGKUshWwGt9tNRhRAdBAcB8V+91+rjFSWhJgOkmNgun1MLaVByREtXSF5bT8HxidovO1RxEKCxkAFGbkSpyiQ9FXiC7mw3GHihRqW9QXqxY9w6J2zrGkJ85ef/ip/+bXPEG7ZgFL/Pubmlti0cQ/F2Sjnrg5wbXyWjrYogiPjNS2KqhfRXcFyMofsWkAzclQFvcwWLQRZwTBtBLmSprrHKNo5dt/mxRlL4pTmqBIW2HGLhFm9hhee/xEPP/I4uVkPoXAr43EZf6Sb1qYN6Euz9FZep+/N42zf1EZ6eAGfMc/IuTeJhmQqm9tZknyEwgHmj17its1NDOsCIc3LzGKcqmiQxpo2Lk9cp1SQWVPnQ03PkYxp/C//+C301Y9RsenPyKaXMd0ekvkShpUllc4iWiVGB8dwbIEXn3uWP/qzP0cOtpFKJ3jhmZ8xOXgO0UyRT06xZsc2hkcWcLQKpGCYmWwc0wmSzk4hyQnue2ANE1P9NLVsJ+GUyrNABBxJxhRFZFXBI5mcvHARwRaZm17EKjloWoD5mRhTziWam+oYWkjxwG/8Aecup7EVDUlQKFkldNNCwEKUZYr5spheFhRss3w7d8sl6sMBQh6RsE8j6JexHZjsn6JjVRSPVyKbzRCbW6a6qhbBLWCXyp+D4yCIAoooYYmgKhKSIlLUyxt9VVbAdrAFBxwBxzKRRAlFUcC2wChLpEShvK9ynDIMuhwE+a44X1YdHEdfgaWIK8ASm4BhYAoitigjICLbMrZUQBAkFEfAKpk4goAmSKSEGgTDxjQMRNtBsMtBfL/q+bUopobpoAZgaLzI6784wO9/4bcpCiaD0/MMxOKYus2OrWuZWphnLhdncn6eu3bfhZWe4+Sx61zu72frph1U1XZR3bgey11LeilObHKCjbs62Xv7NoqmzLo1azl+9BTPPvs6H3vsfgZHZ5ieT3Hk2DDvf/BDlAyZ4vIyqXQRr7+SvstjmGaRcIWXhm21hFsauPbmYUauXGXHnl1IhsBQ3zXWdq2ltXk1f/XtJ9l23z3YV4eo9hfp4CKWAzEzj4sUg1cHaG7biuIzSSQXmRxdYG3nTh7c9RhtNQbr14hYyRhLOYdk2kNJ68T2lKiIJvjK45/j718bY7nopr2lGcWlYaPiSCKSU0J8769SWMksdxwky6IouBC9KpKQIXbmVX733gizkzl2fORWiuksX/rTl6lf24Snzs1CBkxboSgFyeLH54EUz4G1n3R2I2deqWZDJIh5JYMRfJninE5yuQUjvcz77nmIpVODLC/ZuMUFblnfwBuLM1yayrCxroNCaYmr589hN3dhmxaSywWChK1Wky/WcWnkB7Q707gXLOrcFkFtlvTEAkFBJ1RRxfGzR7h/+6cQgxZf//Z/Yc0tj3Lx4ttEqyuo807yyP3r2f/THzB0Jcndd/4Wly9fZ2JiEVsrUKo0GBs4z4fu2szi4Fs0aCZmPonHEljTFuRa3ylwVeMxh9EWYjy8tY7nf/IjGnfez2j4buLTY/h8eXq2qViFZSRFJptfxKsoXL/aj6JI3H3rTt556yWmZhcRJZXKcAWb7tvC8NWLXD4/xHD/JIs5FV9lM0VJpCTnefvVk4Qq8gwOHuHBh+4ik7HRDRlb0FEkUBURt0vC0g1Kegm3s0xueZ749DxOSUQRPKSS87jsIAtTw1w++zO81a18/Yk/4v2P/kcMuxz1IUoKOgKWI6JZKpm8jWCbiIKFIghoLoWoZtDd4sMrFQm7JdwKFPIwPHKC3jUP0n/tDL09GxEdGbemUChkwBERZAVBlpGEcv/oCJQtsICJg+BYyJKDqCmIQjkqRtfLllZBsJBFEZdbRTdtDNNGN/WbiaZA2XV1w/kulb/OdiwEQVlJUgXLsTBEC3tlVms5IiUBBKEc2W2hIjgKChZeOY+lZ/HIaVy2jmyDS/j/OAPq/60jigq66eXHPznGH//hp/nBU6/hDTQhpBJYtoUgOfQNjiMIAtVVlSjuGrrXbOCp7z7PyEQSS/HwtW/+EyVbJqsbzMYSVLhlnvzG1zh58Ed87ctfRgtFOHnmKkFfNcW0SXwxheTWCFdW8duf+U0Ghsfo6mhnKjZD/7URbF1g3+5d6IUcjbXVDF6/wOJQHw+8717YewdHz55Bsg30Up5oXRXWWJyZ0THGBsaJp9J8cuejLMdHqamswe8yaa2voqSIHD/2Di2ddfzuZz7D9//xh1SHQAtaTA39gju2ruHl/Sc4f2aUquq1vHTwDEG5ko7Vdfz133yd3gee4GxiFpmyg8NSxTJVSLBWom+Fm1vSm2xJQbu5NY3Nz/Pw3jsocJFDp4+SanwLsVBCUi2Gxy/T2LYJl9mIhIhplnAJNhSSeBU3luQntZyma42HQ6eGUSIlYqOL9A0usPEjv0tVQxtPPfMMPfd8inN5jaaASkO1H13zY0qVRJvWkUuOcGzgv3P33sFxnfe99+f07QVYLHoHQYK9UxIlUaIsqlhWoWXZluPYjmPHsVNvkpu8N3GubKc41bFTnOa425Il2ZLVaFGNvYCdIAECIDqwWGB7P/3+AcrxzeTmzZ3MvJO8z8zOnnP2mWd2dvd89/mV7/c7gtxkonpV9LdV2G2HtK7SFF7NS6/+I1/6zKc5+M2/JNJaxNbnOXlukmhdP6eGjtAePkneSvKhjz7I+LRA2QxiyjJ1bRv5zB//OcV0mk09WxidmKettxfEFoZrRdziLAEBlmdnaAwHOPHac2zbvJmB9h4G33qRiE8mNT+HOXeMnlUhvvP3T5Nz/ExbkxTix0gmZtjQ00Ri8RrlTAJJruAiMzW5wLYtO1lITBGvC/PdZ75LT28/sdY2xkfPkUn4iPn9hPwBbMXH3fe8k1A4xpmzx6CphV3bVhOpMzh35vscPXyYm275IJVaBVEqICoi/oCCVa0i2A7YNrabIjk3QdCjsLxcpJAt4kgWiugjEJDpaIkzePUifs86yrlpfKEAliPgCDKSrAEyjing2iumdJKg4IoOpuGCs2KupykiPq9CtVRBUX3svfM2qpUi8VgM2zRQFZnRkQn8QZFisYzi9dEQb0RSVBzbBkdAQEJWJBRpRV/UI6kr/mvSDT69LGG6NpIgrZjisbIzlWQBxZVxbPvHO1PH/mdu6dvSfK67QotdybWC7lGwBImaZSIJIGPiuiKmaaBIMookIbkiCi5Bd5yivsi6VY0Y2SReUaG/s/8/jGP/KcAUEUQtzFwiS6ka4uBbc4SidbgSKzQM18UUJGzT4dr4LFdskyd/8ALrd2wlb19jKqMzNDuBIXkRvSstNpZZZWxhlLvu3c/OXbdwdmSI/jXruDI0zuDxIeqaYswk51i1fg0jI1eJ+QOoXpXY6jZuG1jF9NQiX/jWV/C6Au975CFWbd7AtjVNnDl2jB233EmsuZu0lcHrcTj35suoBPjZd+9neLmIpEV47dQl7rltC1FvmKjfw8TwOJIvgRiJgg1z4zPU8iM01zexkB2ntyWPJDWRL3m4PGuye00/rx4Z4l33vJcrMxnODWVQ+nR8ok3Y70NRFGxBwBZtEAwsRfsJJsnKsy26uI4PSaigYKMG42T9Ht5aypJvfJjz2T58lSwXxir0botjuSv2uu6N6qmMS1i0ELMLyNl2SkKGef0YavMerhsLdHXsYe8ahbaNPXilIJ0bbiHYsBcrZVAsjNPbuw89EKOi9XHkyFOkkyOojXVYroYrrAj1ajjYdoWyZlEL7WL1jhD/+I1vsK+nm2jDLAuL8yiBDnbf+RG6t22i0d/Ik9/9I+59+DbS2SAZs56Sfy2HFmwabnoCY2yQJUHBrpQ5e26M3noLS6zQFYmh+JqYXUgwrOt8+BM/w4sHXkMXGsnWXBrjdbzy6Uf54Ls3MHT8Ok6tnkNXalQbZmlrGCQcDrPl9kd549tHmJ6cIl4fI9rWT1NjK9dGJgj6BHLpRVZ1NVBfH+HayCXS2Swhbw/nLlyhsb6ZZLFGU3MbQX+A5bkppp76e2665T4yKY1Na7dTKBqEgnHeOHqM4uIg5VKKjs4oiYVpHNMmFm0kMX+Nno4gy/NFwn4v2fQySsBAL5fxe8IMXZqiviHGtl1befoHf8vP/+pvcWV8gZ7VO0hm8qjBRlzRxcFFEgQcwUUEbNFhLrGA5XSjelRqhoEv6KNUNlAEP6mlRdLpJJPjM6zp30RLcz35fJqezi5006ZaqaKqLq7ASg8pIrbhILguovC2RfMKCIqIKJqKKJg4lo4orijp21g4trsSurvijzsA+HH7EgiCB7gh/CIoSLKEbdvYroXoikRFB8GuoFkVFD2LV1PBtHDsGjI2Xo+GlxE23tlFZvk8VqBAQAsT1Mv/YRj7T1GA+tznnngi7JVRMLk2Mkhja5T5RBbRr92guEnguEiihItLOOzlFz/1KKoq8/yBt5hKlXAMGznowVffgKNI6JUMF04f4sh3X2BiaoIjp44Tjddx+PAxPKqfjVsGyJeLPPnMk6zq7+ZHr7zEXXv3ktTTnB66zNDYGB/80IfwB3zMzk4xdGWIVTvWsTA7y9LkHPUt3agxsEpFxFqVTX0DLC7mePngIdKGy+477iLe1cvswjK/9t9+k1/42Mcwalk0T4w1a7bSv6qTgW6VukCapdxVHrh/A5nFNN9+9gLv2P8xnGgT7Z2bKBVFbt6xhkCkEcezEw8ppmcytPduZlnw4CgCPnQMQQNRQJDEG7+9FTV1QwygCFUU1yKkhtAllYLkZTkXZ7bWSWusFyeXxxCCaE0DFDxrsEQfugcgglpLsb39TygvpGhqtpiuLLFh61OYzhYs1SUvqfRs6eWVQycoK/3M2jsRm1S8hSsIheuMmM0s6TG6CqMIqkPFFfD13EqGthVVd6GI7AqYXhNdb0O0IsTD11FzWbK1cabmr9PSchs/eO48tlJm0+a7CHh0VrU1MLsYpG3to7w8JKPU34QhSNyy5z5sR6NQreGo0OS1aIkEcMs5qrqFq3gxPHWcnl6gJPhwGtYj1fUQj7XwYEeOd75jNWYthTe4Bim6DqHOx/ZYAY9R5OVnf0ApXcKnBgn54kwkEhRSRSQEervamZ0dxhFr1GoSjS1NIIkEfGGWl3NgKaAI+KJdzF8f5er543R1NzC5MMOFs+dZSuS5/baHOXnmKgMb17O1S2Vx9gpONYGrL4Oeo5JNMp+YoFyYpyESIJcpI0oQqlMplCtoSh2lko7umiyl04Rj9STmx9i+bTuHj52if/V6HEe54c5pIworYbYgruQ1g6pJNOQn6IOgT6VYKuPxeYn4NFKpPIVCiR07tlMsljh37jwCLpVKlVA4QiAQwGWFly+KK/2eoiQiSSvCKIIooMgSkiDgOg4e1QvOiniKi4tlOyutUC44P+6Tervp/21xaAFBkLBMl1rNRBRUREHCssBnyHgsAb9hEBOgTXbx5y7TFbARMpP0hgx6QlWalCxtXgfFyeGkx9FqecLhMIJu85mvvvRfv8/09z77mSdafA0EvWFKxSU++vEPcXn4IrrpwXIBVcJxXRzXRpUkVG+NB+7eilkyKRUFTpybw5UVphYqLCZTVAtlBEeksbGdcFsHE4kU0UADyzNJ7rhtN9ncHNvWr6WvsZ07tu6mms3RuaoZX1zhteeP8uC++9DzeV547mm6ejtYtbGfxvZmelr6uHx5gt/7w++TWpqmqb2D5uY20otLVCeX6Oxcy4vnLyLLJXbftI1d27Zx+eIlnJrFHbt389T3XqHklHj4vfcQa1DIzCdxyxoDm0MEtWaef/YE77pnPzet28BL3/wGtnczoboepmcOInsLVPU4RjVNWa2n5I1TNTzEBJ16O0m/M0PALq6ERPKNf29sJMtGckVcV6Js1qg4IkUzRPLiVaLd9QSkAOXCyxSlLP7441Q1HdvVCDhetNo8ojlBLBOlqKexQ3FKdR/hXK6ZgtdHpTyMq/VyYaKVhLaHpNZJVi2gmF4+9WiMA0ePkjF2ETdSPHh3mEfu3s1XXzpAXe99GHRgiA5lLQ9E8ZkKhmtR0wRspQ1Bv8z7HrgVM7nE9HiWYtmgt1lkfmSYH3zraTq7t/DGcAa6tjCltDKnLyDVukhcX+KmLSar+uoopBvwt2/h/lvD1CqTDOWaWJbXUfIO4IpRHnvkkRXbkeIim+KgTxzm0uhVgq0DlOW19G26lS07u7BFi++/fBBJ89K3bgPnLl1luVJl576HePBjv8uGfR+hYd0etmy9Ca/sxQnFWExkMAoGUxMJmpp78Uaaqbj1PPbgu/jB977Omv5uelsjzEydAUck1tLL+dEF1m5bz1L2GkuJHIghlpI6+VSB9FKCamUe167R1tRFLlvDtV1kRya9UEQWfVTLefwBL3q5SnphnpBk0NvXzJmLI+y+61GqpoxleZBEF+kGOL3NZXcEmaqmkipXiNfVoRcyTE1coyESYPjqZc5fPkcwEiZcH+fUubPcvGc3Da1NHDp0iP6eXnTdRPNqBMLySqHJtUAUEGURQXHxSBKqJOH3qNiWg2WZIIBfAMcwqOk6CMKKgyoSkqlguAa2YKL5FDyCgmSspLRU2yRsF4gJ87R45pAzx+iK5mmVpojULtHrTxK1xonY89QpZQLkCSsGql3Fg4UUrOHU8lw4eY6Lxy4zcvwqWkHiS2+d+a9fzRdFAd0yMcol7r13D+s3baRWMVDlwEp+RBRWFMhdEF2oVA0k0UcgaPFLv/IxnnnjHMWqhT/ow3RcdMdB1HWKVZ2xhTKt8R7KpRy5fAKGhrjpzlt55eABZFfGqNlU9Qr7P/goVy+NU0pn+ZsvfJFEIsW7330/zzz7Ml/84u+T14vkCzkmrl7j2W/9EadOnsQ1LRRFY2RsgpvufpiSrZEvpAk3xli3aQtl3WDDxs1cuTDEsZNnaWtspuax2LphLYaV4+zyImu7uujs6KCWs5mZTPD4xzbx6ouvkclMEEtfwRv1EvA6lNNZJK+Fo5uU8iXa1jWipwwiVpIt0Sz1UoGiazA4nyGhVxDUOkwpiCi4Pw79RVHEsmzK5QquJOH1+xBsh2qlBJLCSuXKA4JOoVbFr8rI3l6OpYsEol6WUnNEG7qpyBEcyoj1NzE3P8vAKg/Vmo6gRClLdTQLk9SFO8GOotgW3c0q7U0gaCIly6HmWKCBLIDrqCg2iEIVWxYRNT/FiktW2Man//if+JX3beeFH/wpJbeeuro7COnQ0tZBfGAPWztaefHsOGY4QEQSEKwqfr8XW1DxaxoqBfRaA7kyTC7VUVabmKsWqWspo9aCiKVJ3Nm36G6IkZsZI10sMpNIcNf9D9LRfyffee4ggYjDxOVR7IJOtDHG+HSCgZtvZ2qxgCNHCTf2Mr1Qoi4YRnYNRmdSbN25mYZQPUMXr9LSs4OSKVHX2E5+7Cp/+qUvcfPNOxkbGmTXtg7CvjDpoge7Bve+4yH89Y1Mn06CJTLQv4X2tk4mR2RsI0IhO87U1BSGYax4fLkCqUwOTfEgSRJ1sVYcXGqWiysK6JbE8GgWT2wtyaU8wUh4hYn5L8bbufZa1cZwHTKpPD19MUYunuPa8CjhoJ+e7n4mJiYQJA99vf3UKjqGWUUWBcbHrtHY1EJ9U5iaDo6kIysyulnFdgVESSSAiCm5uEgYqk1ZdzANm5SpYTkqrizhuBaiAJJt4pE1FBcQbSQzhVQ1QXdQlCoeEUIhh5aIxNLiFJpSIFQuEw14CTaruGaBSjWLJqkcf/0t2tra8Hd0kFhcZHZ2lnwlgWMaVAp5tm/ehWOI5HO5/zCO/acAU8dx8Ab9LJcKfOPZQ7R1NaLXQPXa2KKLLa7kUd7uNpOlIEOXZ3nw3vW8ePAHlAsmgs8LsgqWQygcpJpZZClbYqDFZd2mfr7/1BmidR6aV23hB29c5Nc/+QG+8Id/jCooNDc28g9//w3ue/ABfulTv4RtG5QreRKLc2xY28LZwaPUZJGjrx/mEx/6Wb7+d1/msYcfZbQ4x8T1WbzROIY3wPxsiv3veZDXjgwyOzdHX0ChVM3x4Z/5EF/6wy+SnJ8j3l1PaXmObCFBNBpi7Yb1OIbOt772deqCLfzWJ3+eiZkU//jNLyFJfqRwlPlpla99/RAXZie4ddM2bl63l9GxszRHG9gRTLCqOkgk6BDq20x6epTZxCwN6/cxbcl4BPPHTdGiuKJDGQ7V4zY24fF78VUFEtPT1PesxnJEcDUEsYjiNSkYLmUnit35Lmx7kXiPwHIVTGoEBBM7sp0WLcIdN7fy5uFDeBULx/HTLA9z9YpMOLIRSxf4wIOr0aff5PSUZdcQlgAAIABJREFUysDOfRCsp1YrIIoyXiuMagOyjiM62I5BvUdgIdtOZ8NtfPXrz/JHf/Jpnvrhj/B4FULVZdo6u3nlbJL+ffvJH36FzrgDZpVkIY+vr4V8NQjZeTQnTaqkkTE7qfr3kK6twQjJZC2LTtVHrDrHnfECuWqCVLbA4nKF3/jlzyCJLm8+93WS10YZ6L6b/HyNrsYBykUXRwyw49Z99JgiXT3bmFjIU9/cT62UJ72QR9QauHbpEpFoA7OJLB9936+wXHKpOApVu8iMUeRHB3+EJlT57pMjIBlUnToqlkZicYarx8/z7kcfI1+1CXpczMIUG7xbee2V7zA3OYNt2iSTy3g9IQzXRdLCxOJNLKWmKZUNVg2s59LwNQY2bGDPHXux1DXoShQ52ESxYhIOK9R088f3nqqqPxZz9mtRjGqaWCRKLlNk+5bt6JUsV69cpKuri/v23UO+WGFmbp6OtnaqusNScpaH7r+fb337O7zn/Y+jBnzYgh9VBVnRMM0VJSjJJ2GbLq4joKAguCaWaYIgIWIhuDqaU0ORXAy7jEfIo/kMvJpFW1hhcWQUSTQICRJeRcCplfGlbZziIo6t06jFIZMDTWN67DpXrgwzPTzLxo0boVhjcWxqBWvyFfy6S63mEiREWK1DDmoUstP/YRz7zxHmf+4zT8iOhKhK2G6VidErrO/vpVw0EcQV7S3X+WcDLtOVoFwj3lChYixy4vQchi0i3dBPDIeCGOUcH/nAYzz6vij58iT77ruLsbk8L71xlrF5g/MjV7jj7nvZftPNnL14AUdUOT54nmo2xZtvvcGJk0dQVJdyNY/Pr6H6/ZSLJQRBQFFUdEOnu7uLY+fOkqlUOXnqHN2r11AWLbra+zh0+FU2b+olVhdk9PIQQTWAWzPxehza2yJ0dsYZWLOasm4wO5vk+ad/RDzaRq1c5E/+9NM4dh6/J4PtZoj7bcqpBMNjV/nQYw/R2xzCTk2wo1liXSiHtXgBG4XhC5d49rmXKAlR6rrXk5MaUIQauNxglrxN3RPwq2CKJg2AkTpCxRJoWvU4ZclFci1EUUSRNBxZw5YEVEvGNSQkxUWRKwRNg4rt4JUMpq+c4qE9WxAzk/jzQ2xfHebk5QI1pYlydpx9O7wUFi7x+X98lbYNj7HsxnFVCdUV8FgeHNlFElcs14KKTrR0mr5IBis5ik+Q+dpT3+ah9z5KVPLSv7mLhaUqA7fs560TV7h1+xbcwjx2OUe8s4N0tcb01Dxjg0dpCbrIDUHmF66TtZvIyusR1QYkS2BjcJ7t9UsMtGmcPn6IqbEh9t51K9//zpN89x++wq9+8oP4/QEUeRXHhqaYnl9EUr0Uawa+YJDVq1dz+PAJ6hu7EASF+rCPuZGTTFw5wdzV4wxfPo+LwPxSjoamVnzBMM//0+fpam4ik0jg02Rk0SUaj7KUK1NBxhNv5877H6ZoOliuH8up8fz3vsLQ4Os0hgP4BIG2jmb0mo3mDZEvmNiOArKX9MIMpWKF9dt3ky87zCWKjE8l2fWODyN46inXBGRppRgjyDI/KXv39hBtAdGs4Bd1ZCODqWeJ1Xt57cCL1NVFmZ2bJJtN07eqh1wuxczMOHffeSeibWOYOkvLSRob40iCilkFpwYaINsirgdKxQqKJCPZDpptI1RKdMlZvOU5/NUFmqU8cn6KGFk8zlliniQBa47CxCmC1UWCegatUCBAGdXMYeTTVFJpjr9xFH3eoJa3KKVreJQwRk1kYP1qDh09Qm//KmzXYWZ+jlWr+5ElkUAkRkNjF6WaSaFSYSmzyDfPTv7Xz5n+we997olIKIqgSMQaHBRMfv5nPsErP3wV3TZW5LUEBxcHURJB9FFMpPm5j++hPi5x3wOPc+DlIyt2r6JAV0ucDz72CM8/9S3yuSUkqYHTg+O8dHgKyefB8QXJ1BSOnRxkaGSE+x+4j1dePYU37CHi1wjHIjiSzdabNtO/rg9P0MPc1Bzveew9nLt8iR233sJrx44wduEKciREMl+gZtrEYjGefeU5+jt6MKoZGuIa40MXqGTzXDt3hffufz/Hjr3C/ffeji8gYLoup8+c59y5S+SXyvjlANu2bqYxXoekWMCK4LQqhWj1N7N95y1cGznEtp4Q3uww00eeo7w0Q+fAeo4Omzz/ylEWUzU6Nt2O1NBNydOMbJdu5PGFG0rjEpZlo8kO1+eu0SKIXBv8Nlo4jq/lQao+C9lS0RwNGRtBymMpOpolI7oeDBVM2UWyQ1S1IkVbxZFaqaaWMBcv89BmA1dp4momyGLZ5Kfeu5WIPcM//NXfUvNvxQndSsoJI2kGiu3iNX2UfA6yHcArqQRqc8Tz3yeU/hvM5QzJZZHunfs58NpB6g2bxdQ1Yk3tfPub36PBF6CQnGR9XxNzi0kSVR3DEwWnHmdpjuXx8wRiNyELNbK2TUXy4FWq+J0FNvl+yJrWAnkzyZWpy9y1dytrVhvkk+PUcgvs/+m7eOvQMeYSUe76uU+wkMliGFVqxSzXLp9nYXKMYNiPpvoJB/xMjZ6nyVPgfe+6GcVcpJBapFTI8IH3v49KKctbB1+iNneZwvIy977jblJLaWTJQ67ox5aaaOzeTteGO/HG+qm5IRrqPZQLCyQmL/DO27dx8dhxass5utZ2UF/fxPj1KR5+5P2cvzyKIKps3tCHJ1RHqQbXp5fYsvN2fKE4a3beRa5qYiOvCI8I3ChArYyf9LxXJRGfbBP11UjNDSELFd58/SXCIZX2jkba2ptpa28iHq/nzNmTbNmyiZDfz3IyyfjYOP1rViFIAorkYlez+BUdr2whmBlCkoOvlqM2N0aLU0AfGURLDiPNHUXNjhOuzlLvpgnoi3jK8/iEZbxWlaiqEAm3cOqZQ6gVL4m5BI5hMjU5DQQoFyU0rYliRSdQX8dUYo5QXYRQfZCRyXFy5RI7brmZk2cH2bn7FspGjYxRZWJhiWhjO4PnzzOXXEBWBZ48P/tfH0x/77OfeSLsC4EI6Uyachb23LyVC2eukCzpSAq8TfARBYGGxg6cQpFdO6Mgl9m282GeevIAoqSwpn8VrS1NHH/rIAuzZXLLNXyeCKm0QVWvki7r2KqIqNTjVUXmEzmOn7zC7/yPjzJ87RqLk3PkC0skkjkEqUIiMU//mlWokpdrY+McP3mSC5cu88DDD7Opt5+FYo7edeuolmocP3IENeznvjv3kcomWLO2g96ODnyyF9X1Egk1MHjmEG0dMWKNEbzRGIrq5fXXXueddz9Ie1MnuCZd3S0oqoAjNoGkoNZE1GCc04MXaGpRuHbmGEdfeIbOaJi5xDKvnTjHs29co6a7qP4Q62+9l7JaR9HbjGwVeVsVRxCkFf1H2yXoE4g1hbn46us0+efx1jXhBu/CDoNme1EcCVG0ceU8uiIiGV5EVsDUUEQkO0hFziMoMVwhipWd49F7NjJ+7J84dGGZgq8XAmHedUsPmdlB3nrlNTq3PYyhroVoE5aVQ3FAM/1UvDay7Ud2LMJSCnv6u/RHRlicMUmk/Nz9/k8RDSu88rW/ZWB7F4WSSTAQp6a77Ny+nYX5BbrXbWJRh0xVRLB8bGrx4reTKMHtrF0TQ6kLktEF/H6X5jqLzdEzaEKGC9cuc374KhvWtCOI03Q3t/Pe/Q+AVCVdsHDktTx79gKrertpCPt448BLdLe3UhcOUTZNVq/fzvGTZwh5JNzyHCGthocyXZ2tJBeXGZucZjG5RCqVok6qIroyI8PXCPgCLC4vUdewlkcf/znuf+inqIhR0GLohozgpFEFndWdUb76l39MX2srXkFiNjvD8PAYzS1tuHjo6R2gd9VqEnNjdHavolAx2f/YT7OcLXDX3ffz8lunaWrvRhJVJFFEFQXsf3H/vQ2otmES9EJbVGKgpwHXLOFaFWp6iZ07d3Lh0nlefuUAsiITb2pgbOw6iihy+dwlguEQpm0TjIQQ3RKybINbQRZqVMppqsl5xGqO6vIcC0PnCBoFIk6NiFzES43hi6dpX92NXMoguwbFcpqFuQTXLo+wfG2RtZ1bCCkNlPUSQ1cvE29qRvOEULQIBw4cZuvO9eSLeTZt28D4xDVCES8L6TQ37b6FxpZmmttaKVUrTM5Mc2l8GFHxMj4+TV9vH4ZRQzdLfP/y4v8PwPT3P/tE2FdBFqp4VYlAQOXkhYt8+vd+kZmZKUBDFjREBCzbJJ8tYblZXnttmHe84yFCQQ+P/+x+DrzwCm2xJq6cP8Rv/M6nOH5xkJmMzVLZZXKxjI2Gqiiobg3bqWHbOo5poohw9twI9+7bz7s/8ChPP/c6t+zewvziMrolMbeQIVzvXeHw4uKYJgO9fTiqSzoxQ9TrEvaK7H/wQVqjTSQtg1NHB+lva6a9TaVYzdC5bisvHjlOyRHIGVUGtkTR5CxPfusrrIn3oZTKrIvHWF0XxlpKkRoeY2F2kUaPhhRUyRUyzGbTpMxGdm7by7ZNt+ATfFy8OsHVyQXkTJFseZm0r4ktD/53lmpBLFfHFR1wFVxUHBccycGSDBQ9gD+TJNoqoI/+ECyZ4rpH0VwZV7KxFBNLcnHxolk+JAmQTQTTwGMLSJKJagewvSmkWoQWeYpK/jCJ5U0sB+4jG2xmoNPDbcFhJi5eZNTuway7n6JTxXUrKI6K7GogWngcKHty1Eck3PQwP32Hxqq+O5hKlFbC2uUZFiYuU1NqCMsC0XgPrR0uHY0LjIyeI9C1n2MTDkrFQCxm2byxHdmegtosd7RcxepoYPnN76FoqzDMGi0L32Jo8CRzMyavvHCEP/zc54h3RJCFAImpNFcujDA6lmRRaCbt68IJ78IRAly4NIzg2iwuzqE4ZWyhRj45SWbqLEuXXuSd6/1sbxV45LYmGlQTv+wSiwU5e/YNmls1go0xWlrqyTkBpFAbe3fcRFM4TMeOfczaUcqCQlA2AJu8W0YuTDL05tPsu+8+Evk0NT2NrMhYNug63H33A+imi6Z4GV+Y5OLQVbZv28mhN15j+Owphi6d5c69t6Jp/TiSB8QarpVDU7yoiouIiWPqOIaLVwqjKyKu6CGXKxONhtm+cy3JxSnkYCMXzl1ERea2HTejyX76OgfQl6eR9RKymaHRa1IvFtHnh0mdOYc+NYYnM4uam0DOXSHMMmplgdToOepFh/qmFrJj15mfHiWdyuIPRJiZmKGoO+RLFpWSxLVLM9g1Bb1s0tzezPjCGAGfSq1UIBgI8+KBgxR0k3hnJ77mBgLxOJdGx6lva+etk6dp62ikVC3T0BRnanaWtVu2cebMebrb1xD0BNALRVRFZmDdBgY27+TPvv/6f30w/ZPPf/6JOlVFQEJRPZR0A9MB3chy6vQolWoZSdJWdmmqj4Bm4lR1on7YsLaHtQM7MPQCEb/A0PlX+fCHbmFm6hIz40nSVZdQSKKm2yB6ECQFQfJi2gbyjZ43RZVQZJnzFy/w1Euv09AeZ9cd78AXauDYqQuUaw4iKqPji6xau52x6STPvnyIxx97D3/2F9+ku7sR0zL4/B88xXv238HJ4RGuj1ynlEuzbX07HsFGz+ZI5mSuXBrFtg0efNcKdfCF506wbeedrO3bhJW3mBudAt2mlCmwuqWL3HwCp6RTzORZ07+W7z77LNeHLpFOzLNm9QAlU2XwwiSC6EX3hxjY+x5KvjXoSpiaZKMigqCs5J4FkAQb2TWJhm0WJy7Q0hXHXTiFrNUhr3s/grPCPLEdC9d1bjz+WT5NkqQf59oMKYygl4mXZ9nZWWZ2YYIFeT0JtQWflOD+jR7ajTFePz6FHr6ZRSJIPj8Vw0SUlBUqqQiOXEYXotTyFQLOMlFOU0lLvHTwIA88cjdL6avMXT9JR1Rm9yO3IMkCYiHNlUsXKctNLEZvJmXEUDUvy/kaBVejWC6xceMGbt5tMjLiQwqEGdgokRl6jlXVNDkjyomLy9yy911oqpfa4ijPDYv8/VdfwXEDbNq4Bk8wiG17Ofqj77O1rw7ZzOGRRQKBMOmsjq0vsXrVKiYmhgl4TCRrng+8724KiSuMXL3M1o1bGDxzgcxSlrErWfxBlYW5eSLda9hy+x00dzWgWHm8TWtxva0IThDTrOBqFgpFrh59iZOvPo0r2jQ2xWlpCNDb14ppmcwtzHLo0JvMTE5w7vghPvHxR+noCvP8wSfRRQEhEOU9j3+MUMNqRKkBRSzhI8XOVfVs7Y3T3+6nMRwklUwgiT4k2YvlqKiOg18oc8v6ZoRyime++dfcvG41a1rCJCcu4LEzNMVk8ulxMuPn8Tt5YqJOjBpxycJKzqIJSzQGwCdU8EoWilvFXqpx4tVDFJJZZq5P0+ALEgiH0HFYWM5iCDKKL0hJt9AdAVyHyYlJajWdsbFx+nr7UDUPiiTjiALXF+bo3rgJXZURwgFqhTKZbIYNGzagqiqaptHV1UFbWwcuEq2tHZw4eoJUKoshSszMzxNvaqK9p5uFdIoaLv/4o5P/37RGCYIgAWeAedd1HxAEoRt4EqgDzgEfdF3XEARBA74BbAPSwHtd1536t9Y2dQN/1IcluFQMA8dxUL0ejh+/wJ//xf/Dn/zxF9GrOslklvq6IC3NRe7av4a+7iaKhesMXT7Epk3rqRXm+PVffj9XRn5EwKfy6CN3IEQj5HM63/nO6+SyRfzBOjRPgFq6hKTKNDQ1cv+9d/P0956kULEIxINcvL7E0lefpZpKsbavnp6eHqan57k+u0hZCGP7WqiqFT74qd/mmae/za//6ifYe/s2fuu3H+NLf/lFOm/aRUd7F5cvXyaRyNLXGaOwsEBzYzs7d2whm1vkhRfeIpMuIoot5HWZv/vG0+xZs5kmfx2+iI+GpkZy88sUi2VC3kaMQgl/h8IdG7Zw6cIgRsDP2clJvvzt7+EPdmPZBuGWDhp6N1P0NWDLPhBryLaIJaw4OYaDfsx8Gsc2MK0UWkChZIDuyEiyiOAa2DfcK8WfyKu9bTj2L03HHMWBtEC7d5HbNjTx8sE03t3riHnr2N1QZFNdnuSlaVLVeqzIAKYiYtoOsuRZab7GxnFAEg1cW8OqlfGHZFq7NvDD75xg7yM/y9Nvnmbzxm7KNjz++E8zro+xnKsQqkJN9+OL9XKhYOG4MqJh4K+Lo4sBam49bw4v0BWsMplUyXj6aPPP0RzIMDOTp6Db3LpnJ8H6AJevnEOrXiHY/QE+/PjH2NZZx2vP/RV1nes4d+EMQaFENa1yffgsi+kyC8kctZpDTIty8OUz+EMN6EaNhVSVD3/iM8QiNe69+34OXxzn5MUJqo4PQdUhXyLi8VIsFZhLzhKv70KUStj6EjZRQv4WRE2gIDl4JRsfZfq7GkgvzeC4FTb2NXLk+FsIKDQ2RNi0vp3UUhGltYEDzxygff1qNmx5B4HYALftfpBCDipKjNb2EEbVJeZ32LQ+jiyAbltEo9DcPkA6B2fOTXBrTzvNMR9SCQLl05w//grvu6OPNqFEcmKM2zujBEMymcUh9EqJ21f34Oo6VqGEnS4hyjLW7CSLmTRFbwzTWOkW8Po1RMtBtVQmp2fo6OqmbNS4ODzM4uIi9fEG5ibn6Fq9GlnzUzV0hkeuoNsuq3t6eOCBhxgbvkY2m8Xv9bK0tMhNe24lZ9k0RepYLpTRF7JMTc0jiiLxeAMCEu09/XzpC39BIBBAr9ksLCyya9dN5KwaXWv6sSs6aCrLpQJX5//j1fz/G6mUXwaGf+L8j4AvuK67CsgCH71x/aNA1nXdPuALN+b9m8PFxcKkVivjmDphnwfRNIjX+6kWi7hGhcX5CgM9fu67czvvvHsXsYhLT2eIgM9g1y1bkGSbbVu20hhvo6W5G79XQ5YNRCNDWzxIYq5GwC/gWiXMWhZN03CcFS3EsYnr1MUb2Lh9LfH6RlSPh0q1Rjgikk2m6Wuvo7W1noWEzuDZc7z2xkkm5wuMJR1+83Nf4MOf+g2GpxIoXj/rNq6lv7udxsZGCmVIFUwuXhnHFwwRj2ns3LGOLZvWMjM3y5mzF3nf4x9hYNNWfv23/yc/OnKY3k0bOD18iSW9hBqL073lJlJZHdHRmLxynaXrC3hlL0uZPMHmZgR/gKVcjnRumbJuoPqiIHpufLBVRHeFEeUILtVqGVVy8YkuM1MTiJKKL9IEkgdRkcHVV7jQzj+bnP3Lqu//ds1J09bUQbWc4Nix11m9ahu6LSCV5tmzthGpmmQmW8EJd7FUkrBFBQEFGQnRcZFdAVkREVCREWiok8jnZkhMF5krQZY4VnAjk8UW6lfdw8UpHaHsIuHFlOt47CO/TNUNARE8mkQpl8GvqbiOgCgHKdZkfu3zLzF4bpDlqsL41SXMkkHfrbeTziwQ8VZZnrlIKKTiqeugL17HmrZGPILNtm3bqBgCsbYBJhaXaGhrIxAN4wgOqga2XWZqKkklZ6J6Glm/eS+eUD9Xr9fYfvtjDA4t8N4PfYrGlh4yOYNAII5m2siGSTWVxS6WmBkZ5eibB8ksDBNUUsxee42r599kcWYOo7iMbFfQBAdTL+G4Om8ceh3dtFleTlEqFMkupRBdCwmLaKSBI0ev0tJ6Mzu3v5NS0ebZ732PgNelkM1jm8u0xL0EPKBJZbxinqinRNCYo5E5PvSObvb1VNjamKNRv0ykMkZ/QCdi5tBnJmjAIWJU8VRK+CpVavOLCIUKYlnHKlY4e2KQl55/mWNHTxEPd9IY6cCvNjB0cYofPHuQY6cGKdUMtu/cxZVro5w6fZqWlib27r2DUqlEuVIkWhdm9NowXq+XgfUb8AVD2C6cGTyHx+cnFImiherpXNXP6LVxbNNkavw6omWxceNm6upiZDN5BgfPcPnyFf76L/+GLVu3o6g+JEVl9Zp1SLKKonkZPH2WpaUU4+MTeD1+UqnM/wUU/uvj37UzFQShDXgn8PvAfxNW7q69wOM3pnwdeAL4MvDQjWOAZ4C/EgRBcP8NL1WPT6OuKcDCbBEMCEgW5VoVoRbk21/5Ox7ffztHDx3md3/7l3nyO08zfrGC68yj4RIKxZkanibQKPLiK29x6MBZ7tjbw/bbBhgfvETEE2Dw0FG+8qWP8+2nDuCKGsl0muWcimm6WI7NhYsX0Xwa2fkCbs5FtF02bVlDsz/PL33kQYZPv0pzo8Jjj27k+rzB0dOjyGqYZavEc2+dZ2hymrU9YWazZXbfdQ9Hjh3Ar3UTjDXz3effYv+79rC5cw0zw2fZsOE2bJYZmsjhDflAkqkaBp//2z/F8an86h/8D/bds4eRwgL/8Jd/x61bdrF13Q46uzv52Kd+g76eJnSvRbgrhq4o3Hz3Hg4dPEt+Jk1mfoaKYWF5XATRRhOqCG4QAFuAaq2IYtRIT46hKxBt62I+WaZWcYhqLrVaDlWKrfCn/5WKr+u6/xuwesUEjtHEcjnFGyeOs2HbbxCRJbqNBdy5Mo6S4eljQ6gD9yIKDSBWUBwXzQEXG0cUsBHACaK4Jh5xEZ+nzOCR6wR613MhodG6+sNkShL9O+GHh77OJ7fVk7ZlEiZ87cBplqw2yl7Q6nN0xPw4dhld1HAFmWCsme57nmCtNsh1WWKjfx0vn/snzs2n2b59F75aip97z7v45tMvcq3kJTrzCm2RKFY1T0tvK1NqAGnLT+FP+nntPCzkG1m3fj3nTp/A8aRp6peRwu0spsocOX+JloiAG2ymu2Edl49d5O///M/oCPsox8OovjDvu+8RdMvmD77+IvNnL7Og57BTCySnz6KFLZJTV1k9sBdPXZzl2Uvkl2fRFJNKNkcmK1KuFti2eTejw6MsL6bxyTUUQSZVypJUJ1D8m9l107uZXpjl+vAJrNplfEsHGJ8q8ou/8DjxQJFYFVxHR3JqOPkM4eVZjNQSxWSKqk+kaBap9wCWSSCZxa+FUKlgVYtYrsViNkOkqZWBuh7mLk1h6Caaz0tZVyiZKtNLJdoSy1T0ZQRFo3/TWm6//w5mE7PMz89RGJ9g684dxONxLN1gdmKMsEcl0NlOnd/HutV9lEp5Rseu09vdg2EYrNu4FteyiURtvv38C7z/0YcplYrIus3m7j4mZxf4u+f+gXKlSGtrM6VSgWDIz8237iGZTLJ6YD0jI6Ok0gXmFpaQ/SqSILNl01Ycx2F04jqmbv17oPDfHP/eMP8vgP8OBG+c1wM513XffgdzQOuN41ZgFsB1XUsQhPyN+an/0+J6zWRmapnmhji33bSdk4dfp6OrmXv29VPTi2zZ0EFv0z4WJi4zOz6GvwH+52/9Gq8dOMzEYpb6hnmC0QhN8U6+/LVf4Dc//RG0aBmfEeWr3x3m4f2bWUicZcfOFkSxi69/5zTpzAyapqHYIrYtIdgKgqCiKCKxoM3Y8FWuWxWioZPcfvNeFi4PMX51mJ/+2U9y7OjvoKgZIqEoRlVgdrbIPXfexZe/+iQ7tvVx29o9CF6NkZGXCQci7NkeJJ+dpqpfQxDa2LWrl0Ovm9y1cytG/hJdrdv4mUfuQ8jVuHr5DFYhT31djD/789/lw5/8LN89eg7bUfFFm1gyS+hViVQ1SSExTTZ5kXRigVrnZjo378PTtIlSxcBjmngcH5ZoUXYawYGAUaGSm8UKuvSE27murGaD+xaGWmImHyEo16ObFqqmssLWFnEFEdep/vi7sm37x5YTC+pONjlHadOWeYmtHJzM01S3wMkrL5A+fJY9++5A6b2PUrAH1RAJWCvqP5YMbwdFoguWq+KaAUKlq6SGvs+la3Ws3/Jh/JikTImU5qdQMYmtvYdz+ae5dOZ18pF1uLc8gUEnHYUS65q+z7UxG4+6Fn9lmUBomIbYFNnkWg4ernHntqM8c/YrZOoCXL0Y4N3b+hGMCRK0IG38GTY33sXcqeeo1ctU9Sxj1COH+jEKq9i1dx9f/qPfRc1NU46GyCxl0AU/iUQO6oPgrePud9yLVy9y8cRbzE4tcvn0NYI71rBxlLTLAAAgAElEQVR9+27Gkm8ylSvy1z86xUSqjO6LELDKqFYGxxvh4DPP8rkdmzlXk/nqt77GJ969yNyR17k+dBpV0wmIAiRTtAQ6WVpaoqmuhdZQF2PXJqgYOeoawmSXI1hagbA7z2ptkmef/CxNQYfrXxtj/aoB1k21g1HF0xxkvjADlo1rutRpQQrJJN3tXTA7DpqGkyqwlFhkcnIS0zTZunsPs4s5NJ+XodE5+kQ/tp1mOrlET/dqDr95mpt37cDnVVmzpp9oWGZqOkk4EsLjNTl14lUkR2Tzxg0omodgtI43Dh1lem6W/R/8EIvDw6xatYrBkRE8Hg8jIyP0d3TT3tlFe1sH33ryKRoamzh1cpBd2zdy+tR5tm3cimHZXLu+xOj0LHMzE3z48UeZnZpk32378EcbeePMCVzXZXpukYDPT0dbC/F4nLq6CIePn2Amk2J27jrJhWlaYt5/JxT+n8f/K5gKgvAAsOS67llBEO54+/K/MtX9d7z2k+t+HPg4gCxCwONFsA3+F3fvGSTJdZ7pPmnL+6qu9r57Zrqnx2MsZgDMAOCQcHQgQUqikUhpJeqK4srvDa0giaS4l2Jwr0iJEqWVaESJJAiAAOHNADODwbge1977ru6qLu8rK839MVxKe1erkGL/XN7z62TkyRMZkSee+PL7znnfc2deRcJge38f0XCU7TsOE99YoruriWtXr/Pxjz+I7DVYXJxneWWRjo4+XC4XAVcX58/+A9/73pv0D/VQLAgsTcZxeQXCoSiWmcWmOvlv3/wuiaSC02PHMCyq1Sq6blAVNERBxmm3I1kgKXa6OlsYn17m9ZcvMDjYT8GQ+N0//Cxf/PLn+crX/pKVzSyyDLVqlW9+87t86Yu/wz9+969wG9cw7Q4kB5S1Gk888zRd3Xdy7M4jVEs6b509j6J4WFhKEAx3spXL0HtgP8tn3qatoxu7QyKd2+St4cucfOg4Tz3/FrLdjuJRKEsh8gUDSVS4tpgmI/h418c+wl89dYFf//CjrFsCRbsNEwcSNry1Igh1FBMCqgluG53eIMm6HVGEalWjYsqEWjrRVQdIWQzxn0meAVjKT65/Iu0HeDWDzNYmyeUU0aFTZKQWfFaFYKPA8vU0f/3Nl+l8/2fZ0gwUsYzwT9P+D83msmPTtsiujhCNRhkKH6cqKsgWGIKMKjmQDRObLtLprTD0rrv5yxfXkMpQp4BLyGKbtnEsOoPdM47H0cjo5SS+UpR6e5lgVCcccCFWXNQTAp/+yG/zxMWvMzSwjSe+fZmGofvRMzpF+2EEj4cccco1DTHUQEErsjaTJltz4ZBaGdx2gLIvyfY9d7IVX6em+hnYe5Turl6unnmJSP9Bvvvqn2FrBEdzmOfeuEiweRvHH7mXsfFl2vcFsTk9OFRYHbtEMTtHIRPj6ede4t6P/ycOPODn7A+fYmjvKa7OreIOCdSLWbwOH6rqJ5PfYGFlkb0De2lu8jGzmCJXKBOxy8iuHK996zP82R/8Hvv+y68x1NyCrpcQkUhMX8PuFHBLflqcAUqpBHpNp1pLY2aLvPrmBfo7othsNgzLYmx2Bo/fh2RZFKplGjvbsNntdG7vQ/T7WJqYwK9XSWxtcPjYHTgdDkZuDmOaVQaG3kFD63am55ZZiydpaOkg4AuylSuQzW1SM+Zp6eihqaMHyYKutnbmp2fIJlMMDg5y9OAhqNaolfL8/be/Qa5QpLGhgYcePE06tUG0Mcwzzz5JU1s7rd3daHqNn/vEJ6hX82CzMbmwwPrWDSZnp7n7xF0Yqo7P6SWdSlHJl5kR63R296DYHDT4wnQ1hCmn4/8LAv7b278lZ3oMeFgQhCVuF5xOcjtS9QuC8N9h3ArEftxfA9oAfnzfB/xPCQnLsr5uWdYBy7IORMNBjh06QHtLI+2tzXzogx/gV3/lP6DXBf7u777Jq6+9zHpsiY989INsJhYBOHfuTc6evR3sZrNZyiWLX/rkJzEMnZWlFHceexCPL4xpWlSqOrFYhppm8tBD9xFtDmCaOqLI7Uq+ImMYdQyzTraUIV3MkytXyZV0AuEObO4QK+kyS4kcq4kqf/yFL/KFL/xfuBQDm1DH77SjKPDE0z8iliiwkYnjCboxJajqNXTBAllB9XpZW99gdGyaRKrM/FKCsqbi8Hu5eu51ZtdXKVR1vv2dpwn5O2hqaiEYDHD4zgMoqk4mv8pWuYgjFEFyedlMlsiUdU499Ah//oXHEXKbWLkYdquCJGpoikBdlDEEQNAQ0VhdXCK5maZsKEiWgWEYlEwVwRGiotWRFQXTsrhtZXZbmf2f50n/u0WvZVk0KCVESyNtuEmaTvwNDYTdVcrpcQKN3ZRooVjz4/UFqIna/3KBlSt5wtIqbrLcHBnB3tKHJqrogoyFhGCJKLqAW7DhlnL4HQoeNYpoenCpbpy2KqsTl0hMvUVh9gITr32TE/0OyqsXKGklBoc6UESdWrbGUPdOqqkkl5dibNBFUeqlLkZJlDRsXXuYy3nICD2U1F7SOCk6DTr79vM7j3+V/jse5NQHPs19H/4dBu7+MNuPPMDeu9+DLdzNQrLGSlFkrWJj1/GTSIFG8EZ5/fIEC+spKjrcmJinu3eQ9q5+uvsGSRbryDaBYDjEwM5dpAsamzmZBx77DHtOPMTnv/pNegYPc899D9Pdt5NcvsLazAZBt5tMYh2XavLA6X3s3hHFLup86iPHee65L9AqrrLDoSGtLWFLpagsLeAxNeZvDLOxOMPqG+d44qtf440nnkAslKBUIuRxMbOwyI3RMZYTcfr37KZ/3x6OfeiDFGoVXjrzGqrbyaUb15geG6FsaDjcMqVqjopWplzJs2Oon0DIy8j0Ii++fp7YVo50qUa6XOfC8A0KmkE8VyTS0kGhqpNI5bh17RYbqxuE/WF29O1gcnSS+HqcmalxitkMe3YO8omPfZS52SlS8U0syyBfSLNn3x4OHD7A6uYatyZuMrEwz3d+8CSKx43q8bJt9y7+8A8eJ76xidftwe/zEfIHqFWqNLa1ISkKk5OT/PAHTyPWTFoD0X8DCv/1Jvwrqcz/efDtyPQ3f1zNfwJ40rKs7wqC8JfAiGVZfyEIwqeAIcuy/oMgCI8B77Us6wP/2rwem2TtalQxdQ1VlhAsg1TS5PTpHYRCCqpaRZF1apUq9546xZvnLlJM5dE1iyNHj9Hc2c3Q7j28ee4c//XP/4ZE9raIxs4dTXT27uXW9avMTG1x6M6dHD5xml/9jT/F57X9WL7rtqGWXjfxen1U9BI6JrlcGbcsc//xu3nrzJt4WiOINglESMZidEUbaW/2IgoKk1NzJDIVbE546tlv8vUv/jaD++/g6eevkk8ZPHjfXo7sF9h3oIunnzzH3HyGctXHrdElPv+FP6VkTNEUbOZrX/oLtLSOVFcQdIHHHr0fd6SRm5NjHDy4n/aWMH/27W9y/vVbnDhykmRhmbxRZOiOk9zT3MP4Qhzd2YG9Yzc5HORQ2HJ0kdVlZNHAU4nx1ltvs/3gPeDyYhds5C9/jdzcy2y762fINL6XarFAKBRCllRyhTx2ux1D+CcQ/vOcqVRax7t5kZGbV+l+/2+xFV/hyx/s5xt/+mFeuKZy8J2/idlwhKxiUZEqeHT1J89aloUsyxiGgSzV2J5+lnriDRYKCt47P0tGbMIs55AEmVwJGqUqe+1bDLm/hKg38MS1RtKDn0Z1O+gXb6EmXmfvNouzL36fSkbDFohQETXizg/RKZdp1Me58faT/Pbv/iFPPPU29hPvYXErxPveeS/f++7zlEMRLJeFqNtRcZPL6PgiITTJpNnnwaHayGZzWLKTRKaCYPdSyqxgIGF3eymXS9hEi43VJUKxS9wcPs/Ju/fxyqvPUq7XCDZEWI6XUZ1uLMFk965B3nz9JTpDAt1NQa5dH+GOR/4j249+BLtlZ3+fE5/b4Owr/8D3/9tX2VxaQa6LbOsNU0nn2Dc0wIMP3AO2EoeO78euOpDNBGJ+g7/9w/+bBw4/hEv3UsuWefv6dbDb6RvoI9oRJBtfZWFpic7ubi7fvMn7HvsZLEnELJuEGiIQDHD5jdeZWZjHFwzgUxRMLPzBALv27GFyeopcLofHIxP0NjB2a4patUTQ72ZwoB8l0MX09DJz86uksik6u9sIRwIYdYPVlXU0TceyBHYO7sIoZ6hWq6yuruJ2u8nlchw4cABVqjMzM4ummyyvrnHg8BFsqp1A0I0iiGg6PPncj4i0t+EK+MgX4d3vPMW14StMz8yRq5o4DJ3m5mb27NpNfGMTwbJ488wb5MUaR48cZ31pjf62ZqRaifJWjPf8/blrlmUd+DcD8f/Nx/8NmHbzT1ujbgA/a1lWTbit3vptYC+3I9LHLMta+NfmdamitbfNg6reVuM2TZPm5mZcLgFFqTMxvsCdx/oI+QO0tXTyw394kp72Vu49dSfrmyt4wm6OHLiTZGWdb/7jd3j7co6Pf/znuXjphxy44yAD24f42M98EbcX4lmQHCJOhw0QMU0TrWYgCBKSJGFZdTTLQLQsnIrMfXfexcWz5zEUiaylka1qBJwuhFINwdBx2OGrX/0Kzz37I/7hB6/Q3gy/9HPH2cwXyJQ8vPLsBe67e4gvfeExhq9d48WXL2GJAXQxzNpmjsHdu3nH0SZShSILywnOvHCVVKyCYjigtMxWWmdHn4e7juzn5OGdCCEwi162lrM0tQS4vniLc9eneN+9D7A6u8CO9h4Mw0ZddpGuS6S828i5ghQMja6+HiayCnM1P07RwpFaY/SZP8Impjn+3k+zJu6jQapgCHaqgopmKWiiiiWU//ka+ElflTSUiWdZnbhE94M/z7b+KA82zDJy+Q2+Nd5EYPt70XQ3yAIVRUXRaz951jTNn8A0Km6hXfp98vUavp3vI+e/n6ohYRPqtyNimw+lsE5TYYz37LyOqTv4xytQ2PZx6lqN3uIwuq2HxtCT5OKv4Pf2Yrk/QrzURykdp8cTY+nS3yPrWXyRELF0Fveh/0whMEivo4jXyvPydIJU7iYBpwdJN6nm6ricbQzsOkq2mmBpeY1wQzPhaDuFYoWevg4MA27eHMHtceH1utnaipPNpekyFWqVLW5df41sZpa1lQlyuTi6LYjDaaO7u51cLkdNq9Lg8+CobNLoczC6UODEOz7OsV13MNgWprXJS3xjlEafna21LbSSTimbw293UsoVmJm8zn0PHsPT3cjawjwvPfMMtWSWew/dTTVXQTFkqtkc2VKdPQcPMjE7yaHj+8nUktR1k9jmBg2NraTzeQqlMrWiRjgcJp1M0dbcgt/vZ3V5BacNLPF2ETKW2GT7wAAOh4PltQWKuSo2yUVbazPRhgBz81NsZHQMQwHBxo6dO5iZm2RtfZHBwSHiG5t0tHaiawbzswvUjSo2m4329nY0TSMQCHDlyhUWF2ZpaIxyx8FDNLd2Uq7U+Ma3v8WebT1EQ1F0QeBr3/wGd58+TailibNnLpJPbPCLn/x5Nja3SJWq1Cp5wuEwhVyeWrVKKZsnGo2SzWfo2zGApul89ctf4T3vPE5b2MO7//yF/y2Y/rtUoyzLehN488f9BeDgvzCmCjz673oLQaBUh5plYloyliCysJHGskrYHRKmLDI8ssnK4izNTVN84pFfYHl+lK/82Xf4xV9+H+945G4uv7lKpCvA3n3HmJkd56++9jyyLc1LZ17ih9/fw9/89e/za5/5PDYbeEJNVEsJ6nUNUZSx2RRqtTqKYscmqFiSiV4v4XfZGLl+Hr/TvG20qCgEmhqwDAGNCqVKkmwFfu6j/wf9XUHiS2/z4H3HiAZ82N0eglU/aCYtkSiFrQyvvXoVy3QjSC7C0SZG5lb5/jNPcrDj/TgaQuw+dAfPvHiNkZUYXlsz3qYAjrBFwirz6pULbNsWYnFykQsvjONXmijkE/z6536TVy9N8oP1BPcfP8K3v/5VSssxHHYnH/rYJ9mXXmC9GqQeCDE7MYLu2InDv5dSzqDNVqct4KRsGWiahmqrkZ57FkeonbIcwB5qpiY6QXf+i58tL/tpcfvpi7oJsEUtFierL3Lj+hI7T3+SiYwNl66jaiKG5kSQ/0mtyDT/KYFaWZ/HrGVJmI1Emg9RzQpEQ24KmU1sdjs1sYbksJAtC0fVZHNjkp5wAxvCLbrbOnGMrJEKLbEz7Kah5cOcObtGcL+TydRFAi434aY6I9UqqtVGLRehKrQi2O5gpiJRLU5zrCeM4m9hh7eNL3z+U7jtKXbuCFIuCDjVFMn0Fq++/gYDg3v4+Md/gUs3LpIoNeEItKPkp/HIPn7wne8RjIQpVsrYemrs230H3/n2c/S2tnP6zrt4/qmnWE0m8DYG2ZiYYteuXfzsxz7OjZGLeIsLfPJ99+IJN5JZz6MWF8hMDyOlXbQJOTbGVvC6AmhlEZtmY2NiHNUS8BVKLL91BfWGRCE9w3bdhmHvQY9VGZ+4yoc/8QEWEzp6Io8VLGG6C9yYuUBDQy/1Wh2tbOCS3ZSNGhuxDapOleO79pDbSnH5zDkOH7iD/YP72YhNEwyHWFxZ5uRdJykVCzz9zA85evIU3R1RKiWNxEaM6elpmpsiFDJx9uw5zCtnzlGrFskX03R2tjB64wqhQJj5qTHsop2AQyFjSaSzWayNDSzLYi2RQHI4OHj8biq1OtfGZvnB86/R3tnN6Yfeh1ouY1dsvPbmWR5++APYgwHKus5g/06M9nZmxmd46bXXaWrvxd3koam7CzSNO48dQ9fqrK2sgGBy8+YIdQs+/XufZnN9gbenRv5dyPqX2v8nTkD9zV9//fF6OU+kIUq5UgWgVqths7kRDRsOy4MTL0KljlNwkcqN8smfO0lfh0lLg4PJW6MsL69y/MQdLK0s8fKZK2ymNHQ8tDTIvPLyNRpbezn/1hWao2G21jY5evwwMytrJPJ1ZKcN2bRwSCKiLGIgYpkSiixRKhQQLQPTkpEcQQTRhVgX8IsyYSeEfF5ETAqFCl/+07/mi5//HEsb40SifYyML3Hh2hJf+9qvMz93g+n5WRqbtpNK5xjc1c3CwhKrCwWO3TnAnkN3cfn6DEfuvJfnXnqJUr1AKVvBwIbs8FMTVN4aHuc3PvVBYhtxJmfn8QdbsTtcTE5dxVHuxGGlGDqoEMstUzVNrl3K4DowyGDnfnLLy6RLyxDcic5uIh47i2e+RGz2DANHHqWgNeK1teAuxamaV2ltakHLO9HLDop+AVEPo+pObFIcXS5SMdppQCG1+Q2Cpsg9A8c5fayBa8PP82KyCZfvOKbupqbWMSU7trobWTSoY6EJoIgyNkEmoDgJlp5GLmTJNd1LLboHh5EkXTFxkcAma5RppZ7N05B6iT0H3GSqmzz7/BUKW34iDo2Ojuvsd1xmPTVH0jfEq5l3UJaa8LFAUCphTk7T6MxTcyaYWpzj0N4HmHcOYRO9tMkaqlmnIHaQMSRs3hCeYAtbWzmm55e4NTmCLyIg5BJsa/CwuDFLOhPnrVfeJCImeev1b3HhzJOkFhcIEMNZvcHm1BuYiRi5hWVuXpmnVtrC7rThqhfpDNj4wL3H+NiD93CsO8qu7gInD/YhGwXE5AbKxgb2Yg1nuYpYy6BKNarVCulMmbrpwqPa8AdcqE4BU6rj97sYHb1Fg7+LWCrO0NGdNPQ2E+nqZnJxk4mxRWLJLKasousmjcFGTJ+HvoFBLM0inczQ1NyCOxDETG2yMD5KSzCIYFoYdY2b16/RN7ideDLF+voGsdgGF96+yJEjx8iUa/jcHjZXV9BMHX+0gYmFRcoKSE6VVHoL3ahjGib+QBtdbZ00hRuoVSok8zlSZY2maCuKaqe1vRNNN4knUyQzWUxLpDUaob+rlf6+Lja2EmgYpFeXyBk6UihAyaqRTsf4u69/m4Bfoam1E0t20jc4yFp8hczaBuVMnkImy9TkJDsGBphfWsTMZnC7FZY35kikYxw4uJ+7Tt7NV7/32k//cdLf/a3ffHx7Z5DHPvhe3r7wJj6vE71eoablcag1XA5IJTYxjDqHD23j/gceYv+BIV56+UU6erbxvaeeo693L4P7txNtjPDEU6+B6KNcqVAtV6jVNG7dGqG9o43EVpxA0Mvi/CyyKmFhggAiErKooioCliCiyDJ2VUKVLLxOO4oqIbmcVOoasmAh6XUU2USrG6gOB03NzbgdFsNXLxHwuXA4HTS3Bvilj58kvrbA3OQUlarJzRvzdHR08srrz2GaJj/74Z9jZOQKa4kM18emEVUXTqeHibF5LBEkm41SucL8cpqtdJ2AS+MDH/oZRiZGSOfTzK3FyBShd98uNpOL9PS08eFHf4bR67N47UG+88STHNq7i2dffIbFUhnH9neQlzsRxBLV9Us4FY14WaGle4iVtQQ2/Tmao83UaxGSiRQF8wZ+dxuKoSJaAoKqATUUQ8atOKglXsSKT/Puh99JJj9DKa+RDx0kr4XQZSe6XEe0BETTQV3NUlctdAV0q4qsGBSLcfzZcdKbaRr2fpCs1YJN8BOIBOiM2ImvLdHWuw3FhCbmWbn5DNVyisX1OKce/ijb+rtJrI5QLNRQPe3cHC/Q2PcI65tx3C6Tqy9+Ay2xRmNjiJVMmUpNJRroJtvQTdWSUCtTNIVNlraydDU1cHCgnXuP7KCv2Ul5a4Vj+3YTCXtZHxsjNjtGScvy/LNP4UNnePQt5mNzGIJGIBBhdWWO++47SnVtnsJKnCa7m48+/A5+4dGH2b+tg//8W5/koVOH2d3bSMgB2dgcQYcTSRcpxVJUtwq8/MzLtDW0k89reANelleXmVtYIZUq43SFMM0KTY0RHE6VUqXAemyFwaGdVDST9v5ORJvC5MIS6/EtnF4fR++6h1g2zZ0n76Fn+zbCvX0UC1mqpSLhUJDGcAS7005Jq4BlIakqks1OOpujWK0gyCob+SyWzcb86hq6ICLaHTh9fqrVEquLiyQTcSqVEqVKkXvfcS+KKXLzynXGRsc4de99hCIRtjIl8rkciUSCTC5HtKmN3h07QdeoaVWuXrlCJpuht7eH7Tu2USgWCUf8jIzeRFIVTEXmtTNvoggS4ZY2irqJoEh09nZz6tQxHn34AS5fvEI2m2V09BZ7du/Ab7cTCvlpiIQIhQJcv3YVvV7DbZdI5TP8xu/8BtsG+lldXeLG1WFevLb80w/TL37hs497rCI3hi/jcYgUs2XuvecQd5/Yz/ve8zCVYg5J0AhHnGSySb734jmefu557nvgEb70le9w7J77uHF1kt6+JiRJY2DHIBfevoWk2rFMBdXmQlZVKtUyqUyF0+86wczIAp/65Y8xOXETo27icgdRnT4svYBumKiKjIROOODh+NGDzM1PkK9Ublsy6FVEs45pGdicLkRZoW7oKIKFoVfpb9/OffcfZ2DAR2eLk+nxcZZmk8iqn63NMrVajf7tTWSSMe695yQvvnGRsg5NHT1sbCbZvXsP165exhItLEnF7Y2QzGTw2pwMjy7jDCj84md+gT/76x+Rr5RpbDvGzdhFnD4vdjnAX/zXv8Mmu1Eli7bOBt6+9AZNfW3ciJcI73sPWQI45RSLV39ErZjk0MkH6O4fYGLyBn7xIvHFVTqjDSTik3gCZRy2XRiCjCZK1Gx2LEFCxqCcVAgrl9jXUKWt3cXkwnW+/8QkwraHKVtOUBVM0UAQdASxgsOKg2QiShYhp4lciaNW1qkvniPY1EstuIecEaRasyGYOSJKBrdYolxV0YoZDrQJdDpT2MQyXb1NbBaKLC7OUd4qk8puYDftBFwRmlo7cahltlZv4kiPEVuY5BOf+U+8fGmJfftPUSsUKIa60GQvAWmLOwabyZfrRBtaCPskpm5d5LXnv0u1kGV8ZJThkTGiTg+tIT8r63OYtRpB2WTfYJS7j/SxtbxAZmULh1bn5x99N+/ZO8D7j9/Dg/sOMhhy4yzG2dt2W6XMVczhwUDMplm6cZ2g6Se3uEFycYPrF69zaN8JVlYSbG3lcXm9ODwecsUamUwZRXZgs2tcunKBZHYLX8hLtKUJURVQfGHqkgkOlXBzG95QhMWVGPZwlN1HDvPyuTcZmZpmcPt2UtlNquUilmHgCYd56+wbmJLArn0HsbvdrKzHUD1+PKEI7nCIqt3G2laKhvYOfJEGercP8qOXXmErtkBfVyctTVFUVaZuaKzFVskublHKlbj/9APcunWLYqVKoKGdhkiYaDRKKplmJRYnmS1QzadZXlpEUWUmJsZIJreoVMooLgcDA320dbTQ3tXB0kaMtq4eKlod0eXh1swcW9k08c04s/Nz7Otpp1qqcvP6NRLxGBNjNzm6fx/ZdBKf20lbaxOGrlEpFejsaMEX8qN67KyuLrJzYDv7hob44rde/OmH6ef+6A8e39PfQDQaxuVyYbOJXLs2x/TkKq+9epGNWJ5EqkIyXSOV1dAEhYJmcOHKCKUaBP0NXL86wel3HqKt3UfA6+HJp1/HEO3ohgiCgG7oVGtVwhEfw9fHeeSh+3nyiR/wiY9+iPNvjpIrlvA6HSiyjnl7uzqYNQSzzq6BftZiK+TzVWyyiqnpSJKFYRo/3k6kYgGWVUcVoVY32bO7h0hI5LlnfsDE6Ax13U5rzy6uXZulqbUNUamRSiWxDJF3PPRB3rp4EZfHh8OuElteYmtjBUtSMUyRWl1EFlUkUQanneHRUS5dPc/3n/wr/suXf8j4yhrxXJ7de3aya+gAC/Nr1C2Jy9cnOHF0D327W/B1RPjtP/lbhmfzSA47K7eeRl+/Ttgp0tDUiF5Po+gbOPUQVn2eXOY8Pd1BulvezZrpoWakkOQCdR10yU9eArkKWux5pNgIN8cuc2NuGn/LY+RCB5AdIoJo4HMEMetVvD6TntoaPtWBG4GhkANPdhF97iK1/DWGjt/PWhEkRUIQLAKqxr6WCruaRRZnZziwe5CNsVcIKfeh46UAACAASURBVHGWZ6ZwOSUEt0kquYLdEGlv0Th24Bg3b4yynppHy94iNfIKrX43gipwK2FHc+9mdHKOBr+JGThIkSbUyhZdQQd2wYXmCaHrZbb1d2EaFTo6e3jkvR/i8J1H6W9sZntLM4pkEHDasJWqnO4McWJHM+8+fIA//czv8aEjJ7jwve+RTSywt3sbmcUVzGIGl2Qg1ArEF/KYhTqLt+aYujmNXoSAO0CoqZVavsj+g4cZn5pneTWB6nTg8nop1+rk8iWi0UbK5SJ921vYdccBbA4bos1O26GDTI2OU7FEtu8cJBSNYOgCf/KFL9LW2km6WGTXvj109XURj8eZHB/jyPGjCIaF0+6isJXC7vYhqzauXLxOtLEF2eZkdWOLjXSK66MTVAWIRBvJF0q0tXYQW40R30jQGPTid/tRkFFtDup1A4/Hh1GBjq5unF4fff07cHn8ZDIZpsbHWFtaoKujhR89/yIn770Pj02irb0Vu93G3Nwcg4M7WI+tU9VqTI2Pkkxsks6kQJKxBHjtzBscPHaM67ducuzYUR568J00N0Z48lvfYGVlA6fLTVtHOw3RMLMTU5y46y5cLhevnXmdxz78IcYnJkjnM9hcTg4fPcrY+CizE9MkY5v849nxn36Yfv6zf/S4DY34VppMtoimW3j9bizJhajYKFRqyHYnyCqWrKDYbRgIiJKAoRvsHhxidSnOzqFmGqMqtUqF185cI5GpUtMNROm2sZcoyVQqVQIBP1eGR3nXO+9iW18HB/f1MzM2SrlYQpQtZNWGqkiEAz4U0aJWKmAIUC1puJx+RFFCURXqdQ1BUhBlFVGSkDDQ6xUKlSw9Pa3Uq0WmpmbI5IqIqoPh0SWWV1MUyiUGdvVRqdZZX8/i8wepajVqWhmPqhANeFmYHqdcBk0XUGUVMLHJUNIB6uTzVfxeD7t3DbE0t0pJq9IQjnD48H6y+QyvvH4BxeEh4oK27X7y9QqbZR+Ss4V6vcjudpPY8Ct4ZJ1kLoNdrjA3epbu3oOYlWVkcZNgOEi12kfOZmdj4Qwea4nuUJB0zsIebaCWLSJsneeT95/ixuRN6m4vruj7yNk7kdQSRq2KVVFQBYHlpVEGnXnypTp2h5vk/C3S88MMNKrML9zkzod+nmxNpVwsIggWlBMc7xNp8+TR6hpul4uokqaQGiMbL7B/334WNmbo7m7gjh3bUD0qr5yNkbaibJoi7RE38bGbRLwBaorCmtGBs+UIJ04cpZS5SdW2jYwVJOoq0R2SkEzI1Q0CLgGxnqW32c/dRw9TLRQ5vLOVZlHHlotzz+E97Gxt4tcf/RBHt7WjWDkUXSMQbCY7M8frP3yWUIcPRVAQTYnG1maKmsZGZotyzqBe1/GFguw8cpRMKkWpVmZuboqSVqJm1PEEwgQiUXbtHmJiepzmlubbG+nNOgMDfQwPX8Zus2Mg0NrVzeStMexuP8l0jkhD6Pav9EaSD7z/Q+w+dRo9n6FaLeL1ugh6PKjApStXMeom5UKV9q5+7Kqdl147Q19bD+OjEyh2J3XDpFyt4/UG8AU93HfyJA5JJrG6RmJtjQfuvx/B0HEqDiRBYm5unppWp1yp0drRzWZyi5n5RdxuL6rdRltLC6sL07Q2RoitLnPq1D34/X4UDG6N3ALLoqurk3whRygYwOVw0tXajGQZtLe1cvXqdep1nUNHD7Ie36Ra0yjkkqwtL7CxvMDgth2Ewk2MTc0yv7DEgw8/xM4dO3G43Hi8fu49/U5eePlVbE4XumHR3buNy8PDlHIFdE2nwd/At85c++mH6ec++9nHgx43hiVjWDImCpougE2napaxZIMqVXSpji7ryIYEsoKi2lBkmXxii8bGHq5eeYmhwQjN4SDd/Uc4e+kWRa2MIAkgSOiGgMPhpVo1CbW1szg7wfVLb/Oe0/fw+7/7n3jr7JtYNhXdNDF0HcGqI1k6EgZt7T3kUmVEbJiGhWGBpArIsopmGNjsNpyqjIRBslqkva2J8ZtTxNZv566O3HuUc1fmicWLCLJCY0sIm8NLKqmzvDjHO0/fx/rqEp3NEcIeB/VijsWlPAgKhmkgoqFKOgVdQbIk7JKD6R/L+S0sL6IKrayuzLPvYBfLG4sEm1qJJQWiaoUTD+0mp5W4OZGnp3cP4zfPsjT8faJmmqBi4XTJJNfHcLFBwWFRjtWxCwIVrciN2QkamhvQ5v+BttplgqlNgqF+MrKAoNjwluY5vX0vdUXkxWtX6b/j18iKQUQhgUMSUGt+zJrO0GArAXUe3enDG22mlF9ie5eL2OIFZCOKv+deHM4oZqGMVqzisefpcSwzd+VJGiIhYmsxShu36NkR4fqFSWq5GkdPDdDUAKOXXuDsgocN4T5SgfsohnYQlB2wXmXsxgWCff0YLSdRGg6STC/xnod6mV4qUHU30tOs0ehMI2hpfKqIvjVLl98kNnKe2uYCciWLO3MNeXkU58YMjVaRoZAT29IiL15+i713DRFoDzM7fJNSPkNnp5fthw8RCDTS1tmP4PYh+rz4OrppafMS7G7CHXaxGZvH4VNxRIKkyxly1RJVS8cb8NM3MIhuVHB7PMTjcRobQ7R1NKH67ZRzJYKRKA39O5gYm6a1o4dApIlUPM7U5CS9nV1kU3mqxRpBxca5N15GFi3a+7t5+5UXCbkdeCOt7Nl7iOxWjlBrNz966ll2DOyikMhQzBc5e/Y8Lo8fj9fHzNw8sbVZwh4PPoedxfEJ6vkCqbU1tpI5GkNNoAt0d/ezbdsgiVQWw21n++7dzM7PE9vYJJ3MUM4lCDgUFEFnaWaSqYlxDh86RD6fI51Kcf6t8/T0dON2uejs6iTiD5DejJFOxLl57Rq1uk61onHs7oN09/XQ19vLnsFtNIX9yJaGILrY3CrwyV/+VeqIZEsFrg/fYHZxma10luGbt9hz4CCmIDE5Ns2zL7zAjoFBIqEo+VSO7T3b+Npzb/7/AKaf++PHwwEHiiJjs8koioAsGOimE9GUUFBQUZB1sKMgG3U0q0atXsWyLKrFKu949wCXh+fI5i2Onz4FTlhdS7GykMbCom7VAR10HamqUcqn0HSFiq7y0uvn6WwXedfp7Tzz3AWMTIVWTztO1Y1kV9nS0jidXtY2YtiddixTR7LAsNkQJOm28pFgoQsWRV1HrlQIRF3oqo2l1RIOZ5jDe3v5wVNvs31bJ+vrMXp6dzJ8dRa7y09aqNDYEKGSTmGXVbYSWXbuPcTo5AiNDc3YFCd2xUmpoiOqVSTJhmHYsCw7Fhrvf99d3Ji6iiT4cdpbyJdW6eqKkk7U6N83yNKmwEZc4NCuDq6+8GV8xRsEPF6ShsGCtoQvUkUvlfHQweXLU9x97CSSK0c8v0bdcLC94xS50bfpcFlUlCLDSwnaGnbgEi06/CYHBgyKxQqTSz7q0TupOiWwvBimB1HWkOQyhXyOhWorlaqPXF5F0kVslSTxqy+y/5GPcGbeTi27RNS1QbK0xIluhZW1VSJ97+KV4TBaVeeeI3nMmVf43oVZIv07ONwQp5BaJN77LmaFdyN6j4CjF4cngt2IU07PUs6liGs76Oy9h4cONeHODLN+6XnU4gb1lSk+eN8ecitX8WxcorLyLEMNRVrceTqVNKWFi5Rmz7G5cZ2mqJ9crkZ2vYxPDVAoVKnbCpRrFvHNPOlKDUuUKFZM3FEveqWG22FnbOoWM0sTFM0cqDZymQyp1RhtbZ0k55dw+QPMz84RCPjZMzTE7M0bNNlEhs+9xI7+HmTrtjK+bhqUKyXmZuawqTZkTcctOygmc4QbWtjc2qC/ow2/aiPiCbC5ugmWiM3r4Y3Xz6FlS5x6x8OE+nfy5N9+g6nRcV566WVyyRQbG0kU2Y7fb6e1o4WGaIQd23opFbOcOHyI7u4djI1Mkc+WGRzcgyI7aGpqR7FgePgassvG1NoCNcVgYmWWdC5OMpkmFAhjl0Ta/F7stS0qhSxNDWH27N5PX+92ZqenyZfjtHW3kdFK2DxuEpsJGlx+plfXOHT0BJ19A1wdn8bd0kzjth4W5zYpV0sMDPYgmBavvvQaxYLOcqzM9VsjuDx2YpvL7N+3C7fHSaPfT19rK61uHy8/9TRmqUS4rZsHTz/A5vIqC2MTyAYszM7x8tTKTz9M/+Szf/x42KUAJoKhY+rajy2KZWyKjCxYOGRw2lXQa0iyiiWJSKKIZZgogohZz2EXREZvxPjlX3oQh83g7bfeZmU1D4BhWVgWGJqOWTepKyY1U6BuWKTzOrdujPL+Rz9EJOxBMPJolQ3cHoVysYLfHWVzc41DBw+ST2fBtKgUy6g2GbfdhiIIVAoFJAtEE1xuD8fuOUa6WMDvayZfyNPd08xb58eZm4sTjri4NTpBtNlHvpSiVtY4feoeNtbWmJtfQlZc2N1+rly7RqFYo1SqkS8WqdU1fH4HbocTuyyTyyQxtSwer8If/58f4x+/8So3x0Zxu9wMDA3hDfu495FPYPNGOHPhbTLZTQI+kWplixavyY1rc3jd7cTXk/S0D5JPVQi2h3C570AJHWStGCS65y4MeQ/p+BiWsU48s8yB4+/F7+wi6NNotqewaTGujs2heXowovux1NJtS2HRwJIF6jLURBFLdmEYEnVTRKht0WjLY25eI9t6L7h72R3JUp54iiZ9kXOXv0errRO1JBFff4IPP+wmd22B+FaN0Wwj+x/7jyyVdDK2XVxa7CbtvQNTaEGz7NTqSdzVeUZef4rWFhf3nTjIQJMIyavMXXsOLb+MPZbggaFuWDtPcvxF1mev48TL+uwKhY3bBZRMKo/fH8YTChJbyxAOdxJp6SDU1YmuCEwtLHLo+N0oqh2X18O23Tvp7GhBq5o0N7SDJVMuV+nt20ZjYxS75Ca+lkBGJbOVQa9bxLcyRFvaMASZ8bk5fOEIotOJ4LQj2N2EO3rJazq3pqdxBAI0d/QiqA4CkQi6aVIoZgi4HShBP4nEBluJOLLNQdfOnYxMTnHm5Vc4cvAQqa0UY9dvsjYxTcAXoqezm76uPrb39dPW3Mbi3ByGZMPm9CLbFKr1KtNzUyytzGFpGrJl4HKorC7MUS0XaGgI4gmHCERD4FDwhn1s2zlAS1szdxw5xPVbY7x5/gLdvd1k0ylsURdlwcKy28hWa7h9IRS7g8tjY2xmCgSiTTS1drBzaA/bB3Zx7sowy+sxXj/zJr/wK59CdDiYX1kjvrqJKsu88cprtDW1gyHj84V44onv8653nSST2WB+borp6RG2d/TS3dKG225nbGKMkqGxmtzE5neSysSxLI1HH30Ph44coK+/iy8/8cpPP0w/98d/9HhzyINlWNhUGb2uISFiWAKqLGIZOqJlgGUhCiCqNhAFTN3ApqrcPnpe4MDeQ5i1JO2tLjr6GklsbjI8vHJb7Fi2IYoKgmUhCVAVdXRLwDAFqjUdVRGZmVkm7HMRDEiM3FrDMgrYVRdW3YnsgGwmg6HVqVbLKLKEiInH6aCQzSGaJgoSVt1AsLvo39nL3OIChXyNaq2G16PiUIMUixl27drN8voqwYibUjVPyB/h1vBVBnZso6u7j8a2Dpo7O3n5lZfIFypUagamJSDIArlUBlOrYuoaHqcNUahTKmXY0ekg5PeRS4MnEGZ2eYGG9iCm2stKPE65WqFcjmPWEtx9Yh9GLcvKpsr2Pe/ElH0sLG9R1kQ0S6JgOolsP4jp60IM7kG3giSW36arFfbe0UfdCvPWqzfwOnNo6WkunnmWIj4CPUfJ2Lp+fKZfBmxYooopSJiCiCDaEJCQZDt+W5nk3FuEzWWKradJVp04KgtomXHm5mYYPHiak0fuZnb8Ip09GvHVm3R7WplaKHF+2SQf2YE92klGa6JQHqBsyngsFVEv4WST9cvfx51bxJBkDvS1E6gnGL/wEhPDF+jp6CRcBzEVo7JxnY4mJ25/mMJGjUIqx/z0LPlsgeaWdvyhBhoam5BkD80tPYTau8kXcngbw7jtHkbHJpBUhXPnz9LW2oglWazOxmgINjI7vUi1plGplkknUyzMrVEt1ejr6WdufonGplY8/giLq+vMrSwT7eygd3AHjTsGyaWTjM3MEWnu5NbkFDoCu/fv55kXXiWRTOJ0uUnEN2hra0awdORAgGRiE0kWiba28ewLL1Ko1tjZ00elVKa/dxuzM7OUi1W29+1gfGQcm6zisrsQLLAME3uokYXlFULhEPHkBpVqifGJUe7cd4hQIMD+/QeQgFw2gyQKzK4uo0swuThDMpdmdOwW5XKJVCbNrr0HGJ+YplIqcefRIwwe24s7EMTpCyCpt3OyTzz1LL27d7OVzZHNl9lKZolvpYhtJbB7A0iiwraBnbxx9hyZUok7Dh9h98AgPe1t7B/azZlX3iSXLTC/sMrnPv/7YOmYZhVFsdCNMmZBY3F+juGrlzlw6AAPvvchUpUc5y+fJxwO8Nhj76OQS+NyO1lfW+PrL1z46YfpH/zBHzxer1ao1HQESUa1OVEdbkwLlB9bEFgImOZt0Q1LVRENC1kQkRAwJQFV0GkINrFz2wBXr7zM9r5GTF1naTFLMplBt2REwXZbp9OqYyBgWiI6FtGGKFgKyUSJpfkZkok1/vwrv0lDMExsdYtyyaSiFUA3MXWNE8eOsbQwQ0NDgIDPSyaVRJUVBFNAlW1UDIlgxE3vtk6qZR1VUnGqEi/96E0qFY1P/uKvcPb8BbayGe657wRStczuwX5sqsTieoxUsUBdknjkwXfhCzQwMjpxW+AZE7fTDoJA5f/h7j2D7LrPM8/fyTfn2zkndAONnAGSAEgIzEGkaFGyJCtYlmR7bMme8XjXs17nsDVbKifJ8liyZElWoCxKpChSFEiQyBndjQY653Bv39s353vSfoCH663aL1teT9nzVp0Pp+p8OFWnzlPv/3nfen61KqqmIKgy6XyJicuz/OIvfYQXf/g604tJBnfsYi2zyNpajXIlz6FDO+ju8FNMLzF28xJziQJK5AhP/OxvslqoMXzwfvbef4p6JcDd1BX8A+3g7qZY3oHPnSe3ehGzvMjk5AiG5cBpC+wccLKzv4Xb4xPcWizRsu04dmiIWllFsJzIpopq2kilIj7BxpQsVEmlpJs4hTSllSvsb7dJOXcTN5tYjC+TRaXe8TCW/BzrmxfwN64zOxNHsfrQtDhvXVijKodp2rKbqq2gWj78FQ+RxHU66usMevI4K6MY8+cIFTdAaGfm8jucGO6kxeliR98uSkmD1cVFhtq7aIw6sWSJtaJAQHSyfds2woEI9x8/TipTYC22gaULlPJ1dFPi5o3rTM5M0NASpiHahIRBa3MjDeEQL7/yEpZo4ayrrMU2qOoGXrcbhyoR8npYX00SCUfwB0N09fYiaiqrK+u09Xazbc8uTFmkXCrT0NxIKpUk0tDCmbMXSG6m6ersJBjwEwo14HV7GBjoR5ZFYok4ic0kbdt3YJYKNDU28p9/679gKxr+cJT+9nZcbh8dHd0oqotisUZ3Zx/NTW1sbGwyfmecer2KYejcnJpHkEQ6OtqYGB+lkMvR2dZKPpHBqOvUq1Xm5uaIJTawbJv5lWW8DUE6tvSwb/9u9u7ahajrjN0e58KFKwwODZNJp1hdXkJyKAxuHeba9VFm5ha5en2Uugmuhia6ewc4euQosirT1tVJY3srHl+AL37xCwT9AU6+5yQXr16hWCiSjC/T2dTApTffJLG2QXf3AJWayZWrbxOLLRFtCPDM048TjYZ48rGnSCTifOazv0K1WmJ8dpLmzjYee/wkd8ZHefXlV3CqDuanZlhbWeWHN+f+/Yvp7/7u7/+OqLgwbIlyzSRbqJHMFCjV61hIqE43pi2gm1CuWwiijWyBJsqIooglCdSNIrlMmXK5xq7tfYSibuq6TdDfytT0PKLkw7IlwMJGRzQVLMsEAWzLIODxYdR0apaAUbe5evEWS4urKE4HkUYfiWQOVZbIpDNUy/l7nlKtxK2RWcIRN6IoI8sahmGhaW6GhtroH2hh/OYYCgINfjez03O88MLP8uKLr1Kqy9iigoHM/oEIS4sT9A/2Mre+TM026d06RLmQZW0tyfjkzD3f19Sp1GyQZWxRRHI72cyX6Nu6E81wYDkNfvE3PsF//K0/5sSpJ7l64yoeI0fUB363TUvIgWyUqBZy5Csy9514hv7hLk6/+S28msX23l5Mj4e6U+LytSRDfUegvkKjc5pud556coVaVSSeLXL46CA9jUE629sINfXz/TfvULBDtPcfIG9aaIKOmyLuwiz7Ww2aWKFqO8CwMSUVr1LEVZ3nQLfKVKGddaMJb8BLa+cgVd8BanaI3MY0udgqIc3P4uwyrY0+EsU0u3s7GY56efJgF93yJtHUZZqXbxMtLpJfvsLk3GUkwSKfKvLk0cOIQpGZhSky6Sz9nQP4RBe+gEpT6xYKeo3WHTupJbIIbglv0Efb0ADr66v0DA7idXkQLJFQIIxTVBD1GnuHt+AUa6wvTRFfmsWniNweucnA0AA3boxwcOswxUqJLduGyGU2CfqduBSR9bUNBgb7WVxbIhAJ4o4G0Rwad2YnCTWGiK+vMDwwgKwbhEMe9HKNw3sOUkxnCXrcSKZOxO0h7POTWI/hcPlIpPOsb2apZtLUS0Xujt/mYx//JA8++gSKouF2OVhejzF2d4p8qcbo+CSRxhZGxu9w/solos1N2DLsO7SfR554kquXL2BVanhkJ0O9Q4h1CUGQGBjcSt20yZTKXLp+A08oTHd7E2WrTrglQiaZYHZ0jPHL11hdXWff3kPkMnnCgQAtjQ2k51docEfQBJW74zMUanUOP3CMvF5lfHSEBw4eIhryMzF5m5vjN5gYn+D5Z56mlMug2BbhoJ/9e3fR1hVkcuQax/fuw+V0kckX+Mlbp7n/6GGefOJx/D4Per1Ge1srpiriDXjI5Ta5dvUyN29do1YpMXl3kqg/jFS3eerhJ5ENiS/9xTeYNvifQ0wlxYMtyZiWCIKELcnUdJ2abhDf2CSdy5PNlbGwEUQDt6wiWjYWNnXBArmKJGjk0nlEoUB3TwuHj54guVHg9E+vYlgKlqgCJpZdRdY1LMEC20AUbTRZJhIM4fRH8DiCOBUvtm1SquVIF2McPniSzeQGTlVkI5Emm4mTrxbo6m7Dsi0sS6RaNRAlGckS8fhsGhrdpJM5EivrHD2wi/X4Eg/c/zBXrt5lZT1LfDPDZibD3i1ewiE/3QNdaF4v0fZWKpbB+M1R1taTJBJpZFVDcagoziBtnV0cf+ghfvlXf5XP/cZv8vGf/zT7hh7l/R9/lJHp83T37qFUEekf6Kcwd57hoW4mx2+yMj+FZNaQEXjk+HuYmZ5kfv4y6dgN1qduMXfjOrO1dTq7H6E19Cx+R4S5mf/K5vxFJi++TkTTsEUvgdYW5hZv4LY0JMXBZs5E9PTQMbCfWNrC8Fk47Awue5MHhlxo2euMvPV3zOXctLS0Y2oevI4q3f4yu1rhykYThm8LDiuHmV5DEyKY7hW2ePpxZVwM91gc2OdCLoZJVOfpD3oY9GlYqbu0utKY82/QUFFJLs/iDjp5Z3aKlbzNyUc/yJ5Imf7t3dxdmSGXzdDT1kKz340mllhey+MLetGzcZRijq4TRygUs9TrVWRF5dWXXyGdTjPQO8DojREk02LowB4mL52jJexjLT5NIbVJSzRMKV+kp38AWxCoZ3IYIsiaA4cmYuk1CqkktqDg9rhw+zyoTpVKrczM/AJ7D+xBUWUK+QyZeAwzl6NaKZBLZaBuEnL7KWQ2kTGRa3WwLKamptiy7yCq5sIQFGLzMxw5eICVxUVESUFAYmp2jkw+TTyZoqu3H6cnwNziMvFYgnA0SjASJpZYxxfwUqyUWFlbZnJ8nFI2T1u0ha6WLprDLXgiAcbu3AVZYWZpiUhjEzXTIrE4h68hRGwzQUdTM1t7+8ivxwlFG2nv7CEaaeL4/ffRFA6zcG2Mkas3mbw7RbSxFdXpZnT8LmvJNRpCIVLrq8zNTrDv4B6irVEKqRw//N6L/Nov/TLNjQ2Egn4Cfh+qx6QYjzN6+QqiKFEzDT76qV+gmCuwsRFndnaapcUlhoe3cWN6nLt3xlleXmJLbx+HDx7kxe98B71i0Bhq4OSxkxQ2C7REWnjq0cf4P19+/d+/mP7+7/3u7zhVAdE2wDawMbFtC1lUsG0RQVIRJA0klbolkanU2ciVSBUrFCoVVGQqpoasitRqVdaXamysptm9J4rHdjA1N0Msp2PJTrBtBKNOTrcQZRlBkHB7nOhWjZJZIpdNoakmolFFRCWbtfC6u5idv4OkGBx/8AAIOvF4Dl1yoRtQq+h4nRoDnS1Us3HKWgnbhkqhTmxtgY7OEG6/TC23ydvnb7KWKJCr2QgqeDwqs5PLNDe3kIjH+NkPfwzdkKnXRNSyilBJ0y3Ahx5+lL/68j/wsY98hmPPvcCRp1/Arfn4wp/+F1776Ze5k5llcNv9/MNXXufSudM88ehJhgYP81d//Sd88mMf4elHTzF24wJFo0aimOfkkZPcuHmVSimHWakQ8blpiqo8cOgkbncva+vjBNQZIuURjMJlGqM7mFsy8fhVCokxfLafDaORS2feZGJyCueW49hNW5F9jSiSjatQ5qDXJnr3RW6MnCXbMsQLT+0hbzopFW18hQV6PWXO/ejrNIYbGXKaqGurDLkk1l77rzzjiNFsj5CMv8bSylXCfg+rq7fZXC4TdHsoxJe49eZb6Oky2bxArmwhDe/gxWsjBCJRdkYdqBuTNA8043LJ+FWVrtYOmhrbUf1hJuam2fP4Q8Rji2RrJWouSMRLVCsmlZJBejPPife+gJ4pYpTThD1eyNepxhKYuslmNsvq9Ax7jp2g7vFSFlVaAm00yiFsUScSCWIZFVTLxK5U8KoOurYPgMNFMlvAMGF5bp6+aBPf/uY/4Pf52HHg+PT12wAAIABJREFUIOsLy3gcXtY3N0mlMwzt3oHHpWDbBtlMGpfLTzqTJZtKc+viFRwI9DU3s3XvNmiMcuvtyyg5HaNUJba5QTpWpjnSQsDjIxLwEwn6cGleWpsbGRocoL+3j0sXL2HUDYqZKieO3QdUuHztHPlilnyxgtvnJtjaxJ2lOdwNIdr7ezhy7H623beLUHsLY2OjrCwsIyBx5IHjrGQKvPPOJUZujLARWycWW+J9H3mWzh2DSEEfb9+8ytPPPsbx+/bRM9jGwEAn/YM9JGJrVAtFRs9d5oWPfYyNjQ3qZp3rVy5RyqSpZTJcPPMmsuDl9TOXmFlY5uWf3sEhJAmFffi9Tg7u30VXews/fOlFzIzFA3sPsG/LVryyws1rIzz5+HM8/NApZEsil8ohGDaKJJPZ3ORLZ/4n8Ex/7/d+73ccqnrPD/1nkYCi8P8W2g86NpIkI0oypimQL1YpVgXK1QqmJdHa0k2tnuW+Y4N0tzZw+eYIq6kCdQQQDCy7TF3XMHQdy7aQZBmXy0WlVEKVNbyqgl2r4dAcyIpKqVShbBvYwNT4JD2dfewd3ke6XCCXTRMI+MCsI4nQ2BBmJRajVCiwf+8wolXF63KgyRL7j5zgC19+k5JuYEoasixg1CuohkVTQxAEnWKphCJpTE9Mk15NYJcyfPjUKbpDQTbTcdw+Pw3tUWp6CVWA2fHbNLa1UZMbOLDvPezeuZfN1CqZfJqAr4VvfOMvOXLwMLG1ZWTRYnFugj27h3ngvmNcuHIFC5lYLI4kybicLrbuHOLy2BK+YBjBSrN45yckKjUOHXoUjydEMb+Bpul4XV5S8QqdIS/pTAVX815UTxcCATB1er06M+e+iSs7SldXF20d2wjk8iwvLRENa3jsGBuT55kfucCHHj5B9vZZ+tUsG7d/wsLYaRQphiVsYhopqnqBkydOsb6aoVaT6O/pxqqV8bpVJFWif3AQwRlFd7o5f3OE9ZU1fvuzn8MuFplfmSMaDrGyusLWrTuZW1pGVhy09HTz0ne/z7YdOxEFkVAoQCVbwaWoBD1eAh4vsekZbMOgnkoyfu0WtiHQ29fLRjqF5FbwRMJslivMLK3i8waJuMLEltdxeV0gK+QKJUqFCl1D23E4PGxuJvF4A+QLJZyKQioRZ/zGDY4/eIxAOMDIyHV6+3q4cOk8AwODtLW14wyF2VxdR5RkLl64hFNz3hto+v20tLZTLJWIJxLMzs2TzxbYuWU7ixPztHT10NzXS09zP5lMHguBv/27r3Hp6jWKhsHEzAzxzSSpVAqf10c0HGFpZRbNKdDX38nOHdvwB3zIisTdmUmWNlbJlnJU9AqbyQ0i4RB9A/38+V9+ge6eftLJDJViDYfqYj2Z4f77HmTr1mHq9TqnHn6Im6MjfP4vv0RZt7nvxEOMjt3G5XDQFPHhEEWWpmdoCYVZnp3l8fe8h9OXzqBKFopo8eZPXiOT3KClpYHmpjaCwSaeeup5jj14kkx6CYfDiY3N/v0HSG6mcLhcnDh5iqH2NoqpJNVsBtEQ2LntAG5HiNnpMa5dvkJ8dZWp2+P4vR4yqRTfvDH+Pwb1/K9aAu8C3P45yM0yzP/7kX8mrKatIgoSgiAiSoBoY1kOSmaFgl4nO7WMUSmSLYNtGuwYHuYnV09TsmwkScWsayAriJKIU1NwaCr1UgVFkPE73SiA2+XGNE1AwhYEdFHB7/JRyBkszacZjd9FbnBw/9HDtLe1kE4kcDsdVMtFPrRzF2+8/gqiXqarJYLH7SIajjC9GkdwgcOhotkiRqWKSxPZ37MFl62QS6RYnpzHJbsRy1lso4pPtAjVi/SFvbx5+Ufkp89RCHkYX48jmk4e2X6Yo88+y2zGTSlTQbQVbty8yvTMTd771DN89Stf40/+4HdxSALDvU00RRuwK0XGJ25hIpDO1fn4z3+Wb3/zqxw4eIxv/egKO09+llTVw+zUdYaOfIBL107z0wvnqaZTOMwikYBKphIn2rSbcMhNRvLQ3L+F9ZqAIkG734eUmmJ4KEKL0UNb81beujRNtBLnQG8bX/7Wl2iI+tnT20XR28DrX/wCBzob8Sg2ewMSwUPDiA4f7S1tXLp1keeeepLJiTusJde4O7lBZ2sDTRE3G9UkuVIOfWUVxT/AuSvXKeQK7OoforSZY+fW3UTLzdwcvcHQ1i3cmZ6lpaUDW1OJl2o89twHcKky4b4trI1dpi0Q4tatW2zfsYNMLkso0oDX60U0G6nFs9QMk7nVVdazGYKBCFowgsfr47Xz/8iZNy/z/KmnGeruxeFSyRTydPW2YusGY9dvszq7wOFjBxCRiK2uIEkiTk3ivR95P5gGBjbRSABbtth1317qVZuAw8nUrRHq1RqCZfPMc++jXqkxOnIblwCi6mTn3j3EYjE2k1m+9pVv8J9/8XNks1WyuTKGLLMxMcVibA3Z5cAdDDCwZyfNPd20NERREEmsLDMxMsLubVsQPUW8HpXG5gix9XUmZsbwuT2cv3KBLTuHQVOIhAPs27mb8du30RSFX/7Mf+Dzf/ZXuCQH4c4O1jcKRMMdOB1+3jr9MnqtyOBgF9dujXDsxAnKhs3YyCiZZByHXWfs/BpHDh1CKRZoC0fQOjsYfedt5Gqa9z/6BF63j0e2DFHI5GmIRpE0CUQnlbrOjdERPvPC08STMQJ+J5XYHEGng47OJmLTdzj70+/RHGmgr7MXf6CDP/uzP8XhbaFS36RaqaOqGi6/l2u3buJyef7FMvZvQ0zte6A227bfZQwZhoHL4Xy3UzWMe+w+27ZRBBEsgf9O8xNsCQnQbTBFmbouEPVKVIoK3/n2D9h+8AkqlXdI5gwkRcGlBskWY3hcbpqaouilPEFfkHKhCJU6qCK6aCOKMjXLRNFcSJZJLltBkt3kilW84SC6rTNybYzrl27g0BTK5Tx+v59c9hzvfeYUJx7ay62bF8Cuc/nyZY4+9TzlAvS2ijz96CPsHRhgfWkBRzHH7aVpQEZWROKxFWIrS7T37qCyVEaVNTbjMVZmx9naHUDS/DhzU8i2RnE2x+yrWVarDpyuNnbs38PXv/anfPDJU7z+rc9jCw6oG0heD6mijoiKIDup6zbJZAFd8POTn75NY3ML3/z21/m533uNkbiftOnE03GMmrSOVx0hnxxFNBIolkwp40T1Q+OWdvbt3cbcDy8Qz8UR3F6iPoPCwgJN5gxdQZWgc4jXXnuL2OQsIa2CpiT4peffg9sfZG1ygemCSVvHThr72imUEgQbohzwhzn92h1CxQB97QeYHpvD9lpU6inqVoU6RSIdnWTLaXJGES3Yzk+u3KBerdIU9PHIiSNMTt+hr7Od185dQtNs8jfHCPn87N7VTCaVQxFVbl2/xf3PPMXayDVmF5c5tmUrXlVlaWYGxaNxZ2IVX8CLvwrb9wyzmshzcfwOzqYQUiCAproo5Ets27KVU59+iJsXr3Bp/Do7tmzF4fcgaArVahW3z8u+wwe5dO0aRx8Kcf7qZZ586jG8DpGCUcPb00vi2nUCbj8Btx/N4eLW1ducO3eeY/fdj9fjo5DP42ppZeXyFfqGtiDLMsFIEz9+/TU6Ozt5+fs/4ImnHmdtbZ32rk6W1tbZua2P4Z5+3njzNGgKHf3tbBneijfo4++/8mVkUSC2tMTRgwe4PnoBb4uDjnArY3fusmv7DnbsGGZudoq9B4/iDQfvJaapCoVUhtTiPOfX4rR2dvKz732WsZt3EC2Ji+cvMbRtG2d+9AZDQz2YhkQ+sc6JAzsZHZ9EkRQev/8gAwNdVBIxbH0HuWyWrv5uJsfv0BiK8Ojxo1Avk19dg0YbZ66CbIpIgoMf//1fUKkL7Nh3hIHmCIKVJx+fQa2GaGhpYvT6Te6MXEPVnDRt6aaQyXNjYYr1C1fIOUB3S0i+dmq5IsliifVYnGy+SC5X+BfL2P+npP1/rZJlyXZrGqZpvtuByrKMbVpIkvT/6Ept20awTSxEQMZGBFtCokJd1jEFEcX2EbFr/MILe/hPnzpARWpmy32fJWPImLaCYOvUdYOe9haMWh0Ni3qxiMftxqvIOGWQMakaJnVboGZCnSou1YskyFh2Fa9XQqmpCJKIrtcwbQOwCIUDpNLr5As6f/J/fJhKKU0+W+Hu6By2LNLd0Ut/Tz/Z1TiFlVXaIw249DKz2QwrpkFBVfCHI1i2QNrQcOSLDBkS+ZVFlkrrPPPoQ2R8VRJWErNSoMPbTTILzuQoPUPH2DQ0RheuomkSTjVMuHGQxz71H/nIe38GXyTAb/z6z/OjH36baq7KRtrm1/+XP+ATn3yB/fv6KOaX2PXgL5J17SZedONSwFleJDH6I8zadYzCPHLNj9PfT1nJ8p9+669wUucff3SegvcgHn83h7ZuwxF7h4t/+9ss3x3hU7/x+7z58rfYGbWwPSHigoN6oJl63eLamXc4MrwNv1Bi6Ohh1vKbINbwaDpTi3EGe7vwu1x88Qtf4LkPfYxvfv8VSnqNn/vws8zeuUYk0MFarMrqCrxx7RyDna38yi98Asmqc/fObRKbG4ytpnjhvY/TGvJi5gqIVZvYSoxQtIG33j6Hx+9iYGsvW7f3sHL+KqpDwRcOkCpk2CymaGxtRE8VUWUv0/MbtA0OMb40R0W2aJAUTp16hDd+/GO2DPbz9jvv8Pz738fc6AQ126SxpZn2rh7Ka3HWFpb4weun+cyv/zqetiayq0tkM2ucH59hZ/8gE7fG6Ao10tnZSaAxQrFuUC4UaW9r49WXX8HUDaLhCKZeYz2ewOl00trRjdcfoFarEXK4kMN+xIrJneuj2G4nSdnkkRPH+epXv0osFiMQCJBKpXjo6CG6ujpoa29hfX2Vvu3bQLAplrOcOX0OnzNKNpPhsUce4uzZN0ivZChbOm6fl462doxCmbd+eppQtAFb1QhEm9EkN/t3H6BaqKDrNcrFIl2dLWQyMSJhlXBQpFyu4XR7Mcw6iipQXl3A9DURX1vH43QRdvuQRBG9XOXc1XME/BHcbi/5go5liywsrBCJ+smWdNKlGvc/cpJCtYjkkLh1cRQDaGzvpKjfW318++Jl6tUyIgLjkwlEj4bsjpLO3FvtEmUZUXGiWyaGaRPLFf7HJe3/a5UkSgQCAWzbxrIsqtV7AdF13Xg3kf2/44UFQUCEe2EYtn0PSSzaCLaOgAGCjGmYbJZyZDZzCEoVQSjz+JO7+ebLt7AtA9sAUQAQME0Th9tNrVCiWCziDwYBG9u2/4lTpGCI4BQULMtClEAQRWLJTVpdLaiijCTa2JaIYVYRZQeCLPEffuU5BoeGGB29gsOl4fS4sfQSidgiuY11OvwRHOjs6O8kGA3gm1+gurqG2+0hnkoRCkeRFQ2nLVGMZ1DdfoaHWnnzyl3cQz68PR4URUDy+Lh27hK/uNeJYKZZTtXobPIRbYpy9cIdFDnEjddeYd++fcTSaSTVSb5QQRUUHJrG+nqCz3/+8/z5n/3vuDwCDxzo4Wtv3EZ0dVIpVViZukCX24HgcOOLNDM/niGd3KTvcA/JxVV8io3LEmhvbiLU0IWUKSJsjvGBU/tZ7wyQX11ioMVHXyfknc0oYog3rs/gUj2kNtIwZGOS4OWf/CM1t4Kq1tjVG2IhPUpzp0E5qzA03Es+UyTka6acW0BzSLh9bga3DnHp6qtMz9RobW0lEgzS3tbCxuo8oiqQKeQQFIWGlha8CqiKi9e//wr7duyhUq3z2KlTTM5Nkc1mUZqiFAoFGv1N6JZJa0crYlpkfOIODlNm985DdAguos3NtG7tRw15efPr3+LvvvgFtm3bxqXz5xgY6mMlvsb2A3tJxNZp6O1hcew28aVV8skUH/zIh7gzcZdQJkEw5MHj9fL08+/D6/Ix2N1PdSONUdcZuzmK7POSzWYZuXULWRQZGBpCVVX8bhfhaJJKrco3vvEN+rcMMrh1CF2UECp5KukCul5DkV3cuTOOIurcf+wIPo/3Hj3TsrFKWb7z7W/y/g+8n8WleYIRL+FwkGQyiT8QYm0hTndnF6+++horq9NIZZF0Pkfv4ACFTJbBrl5+6VOfZnp+ju+/8ipbt+3E4w4iAYokoIoafpeLerlEwOPEpYpYpTTryyu4vD4kBHyajUsy+fuX/pGO1jYs3WDn4FbWV9dYnl8g1N/O5Owiw9t3sbwaQ1Xc4POQNWXw+JEUi3984xyaR2MltkQ+UWFuOUGqdB7VASUdZAS8HhelUglkFVVtoCp4qUsZbERETcVAAEnFlAD+Zd3pv4kB1B/94R/+TigYePfetm0URcHpcuJyuxAlkWqthmGaSLIMkootiFT1OrIiYtsGiuDElgSQZQxTxSEIJBLLPP/cVnyqgl4S+f7pCSp1BwI2DUEf9UoJl0PB1mtoqozX48LldKNIYOh1ZEWlUjNwurwI6IiCiSSaYJtEww3U9Sp1q45u3RtkqZoDp8NFZ38f+XKFYqmCXrOo1WwM02Tnnv14PA384KUzrMTqjE2X+cnlZb7x4g85ePxJvP4WDtx3jL/5+28S6mhD0t2klnM89tQhHn7vAZR6mm3bmxGMLFu72hAE8DWFmJ4bZymtUrWcdEbaKMYrOOQQd5dW2dLSjF/Ms6VBZHrkLKrTz0qyhiyrNAS6eOjoKVwemVQ5QYEcraF+Dgwfpi/spbB8Dbk6RiF2m1SxytFHPkjZrfH4YwdITN5kY22D/v4hfI4Al1/6GutXvocjdYFmj8XYjdtEwk20tLYRX06wntUw6zUm1vIMHhjm5o2f8oEnnuDQ8HE2qjk6eluo6xkO7dnNKz84jcfRQNgb5sevvM6TTz3JZq7G3dlVWv1OHjr1BHPT6yzFSiwnSmQqBmJ+nReefpTbVy7S2tqEqalUZQU5XyVky9ibRRKzC/hdblxOhfTSAqpUJhJRkMQ606Nj1NaKeF0+mtrbeefKRZLVHI985hO0aC3UqwaKYbI8Mc3SnbsERI3BriF2bdtNY7CVlbkNxIpGf/Mgd2YmOXv2CpKpIEleWju3sP3hp5m8e5OA33cPJW7A7Zt3aWho5uVvvcj1q9dobmhC0C16mzto6R0ilY6haiaDrU1srK/QvHMLk/ENLo9dI1fJEwoFaG3qpCXSimSCrpt4glEu3bzF2sIa/+tv/wGDje3Uc2mym+tcP3+OjdkV9g7vRTdhPZHm8q0xRm5P4/c2MLu4SKWs88DB+yjEY6xMjPPeEw9w/OARDm8fJKiJNHjdOFQHZ06fpa9/O8Pb99PQ2IlV0ylmNzHrORZXF7ly9QIOt8RKbI623ghn33mHUqWCYVosLceYXUqylqrjCbWSSJVYSeQYW4hTdwSw/U3odoCM5WC5YDOdrHF3LceVu8ucu3KXawvzvHx1mtlkhneuz3J3KUeqKlNCQw0EEFw+VK8PyesHpwfB5aUmiEiKhCrb1OwCmiqgYRJ2qfgkG79oEitU/v0PoGwbBElBlVVs28bl8b072a9UKgRCXvzBMADVahWbOuVyGb1SRbTu2RR1XaSOjmXbOB1+TL1CyYA33rnL+x/voaO9BaNu4fGqSJaEpspobgduTaVaKGAbBpZhUyoV0DGQBB2/N4DqFsmVqmiygq7r1Ko1JElCQqBer7/bMYuiiGmaZDIZbk/M4HbBZrwXt9OksTFKciPJndtLHD36EOkKrGY26O7bTqak42rq4Y+//HVMI8fhE3t4/tn3cPbK23R2HsfEZGJmGlUOUxPAL7jwexv43ndeom2wjYMNEd5zZA/XfxrHKnmYvLnO+noMfTSOpnp4461X+NVPf5T11RXcap3J8ct89Od+AU2S+ebffJcrb30XzVVn4q3XUL0mKzPXefUHP0Zz+PB5JUJunbhg0djRQTDaQEumC70qMXJzhoffdxB/0MPXvvzX+FDojPo4vL2b+Y0Fphan6O/uAqo4Iipb7jsI9Qr5+RxLK2tUq2WG920jPT5PulBmbGUOQyghTsjsv+8oDk+Uixfe4qOf+DQ1Xcft9VCuFOgZ3MGlN8+z/9Ax/vbrL7KwtkKpJvALDx5n5NoUyaLO5ckf85u/9lHOvfYiH3/vJ6hl8px7/Q327NhOJpuiUC+xfVs3lmwzH1vF5fKx9fhD1HfkuX1nDJdpY2leOtvbeOkvv8YzJ5+mmC8wMT1FuVynb3AL64k41XIMVXUQDIYY2DZMMBgmmSuwZWA7a6tJlhbX0esmXV09XLs6iuw0yWfKdHd10dwzSHNjB0gWA23tVCNVWtqaSSU3+cGZ19nSOMC19UkGj21nbHWDncPDBBU/h48MoVgyg72dqIbB+uwK8dV1pFwK3E4uXn2HF973PFevXuXyj75DIpXAGZRZWVuko72dnVt2c+n2bcLtHTS1tbL/2HE0RCq5Ao7eMo2hBqqZOL09QdqajhKJBsgtLVAsF7h54xZ+fyO1uoPnnnw/I7OjvPzaaVq7e6mXS/R3dyKhc+H6WSTNzXzKz49+8hYreo6A1oqgqCxtVhHUDlY304g1B2vrceLJBEvLq1TrFrp+B6/fSUU3KZgWmsdDuW4i2hJet4+04Ue1PUgtEmXToqmvG7NWp6TfIwWIioYqy1iGScUq3muKZBlbMDGsOlbdoMuh4vV68bjdtDY1E/D58fv93Pyrv/8X6di/Cc/U4XDavT0DWJb1LgLYtm0Mw0BRlHs4YFlGkiRM00Q385imiaZp+P1+qtUqiZUCVTuDadfRa04k08ahZtjdI/Hat7/E0uIi973vD4jlQQLamwOIpo1gW8iWhYyNQ1PQFBXJrKHJAr5AkEQmj6x5sGqld98hHA5TKpWo1WoUCgVUVUXX9XffFcuDKNdobfez78AQxWKeWq3G229d49hDD1O3Zb77g9cxJCeVqk7I4yPsFvE7ynzm088SbfHyvZe+geLeT1AJMtStUc7Pc/3cWSopmz//6z/m+u0rzK9NEgkHmLs7zcnjP8vS1Cw+yY1VNVhcWMbl9XAntU5IBacAgtPFpuDhA7/0qzhcNtfPnie5sEAll6StI8r03AR2OEKlYFGt1FA1gVwlRkPfdgRRRa/D+sIqYrnK4T076N69HQkH18/e4Oi2rUyPXKavwU3RKVJay7JvaCfLi/MsZZc4cOwADl8LiaKfb3zvO/Q0SXQHAtQSJXY9eJwCGd6++Aa6Xqe1sYkd+x+gbaCL5NS9JXLV2cRffPEb/G+//Ov8w0vfZ+uhQ4zcmeDHP36dh08+zHvv38fZ22vkDZldO7dy5vtf4OPvfxBhroDP4SI+v4rmcqJj0dHdhWnVmFiYwt/QSKSlk2JVILptABSZu1evMTMxTktDlGKhgMul0RxtIOjyIQgKtiiQLpWw6wIry2uMjo7S3taFYVjs2bOHQrVAqVSio6OT1p4t5BMJKpUanqCGQ9U4f/YcDlVlM5Fk12AvVb1OpCGKrCo4PG5sUUC2wtDlhx4fcz/6CWGcfO+r3+Xkcx/k2qW36GiKsLm8QHOwgVqxSrGepiqLiEEvbX19BEJhfB4/K6urdG7twLAquJxOZkZn2No7RL5YINR0jxU/eWOE5mCEzZV5ov4g9VyR6YlJLEmgYllEIi0UyyVsWyCT08lmoVaFkpzDFFXypRqiYKOIBn6ng3D7FnJlg7IlMre0yOVbl/E4nCSSFXQLShYImoakOnE6VPL5PE6nE5/PRzqdwuVy4Rfr6LJAvlRGc3uQLQFNcWDXVQQN6kaZrf29VHIZ3KpCuLmBztY20E0qxRJBj49U5R6kz+FwIEkSTqcTTdOo5SqYponL7UZV1Xc150N/9IV//54pgAXYggCCgC0I2IAgSVgAoohumpj/5KlKsoYo2WgOJ6l0Dl3XaevsomdgP4tL04zeXETRvNTNIvFNgcnZGEG3zPt/5n6++NVzyLaGYNk4VAVDr4FpIssSjn9CTTsdMtVKEZfhJhj0k8qV8Kj3Prpt2+i1Gh6PB6/Xi9vtJpfLYVkWpmliWRYeRSNXymPpBv5AiHwxRzpfoGxYxFNZ2rv7EBQFwzARNYX1ZJZKwcDfE8Dp0JBsi2efepKzV3PYNYu1jTiVYhLZ6+FTH/kIV8buIGhO/KFmVpdX+NQnf42ptRXilQ3ygkLE6cfXqBH2+3jz7gzekI9tA30YosiFc1fxeyI4m9yo2nXau1qZurNBfDOFoLjR63UkwcTvFkmmEyiaRDG5js8bJuQOMZPcpL25hcRmikMNrZx75xL5comRiVHaW8IM7egiL9pcT1wDh0LBLLH/gb1EB6KgtXHz7QUKpTKNzX2gl7nv+H6WSykujZ0lV80SjYbJllIsxKYIhEF2wtzYPGfe/D61uotkoYQrEGF4zyH+4ktfpaezhyO7drKQK5Aupbl2fZzLZ17mcx99isaWbkqrE8zNTNPR3E7VNEmlM6xtbtLYGGZg2zDrmU2WYitcvDZKYKqN9pZWDL3GwYMHCfsDmLpBMhtnZWGJjuNbwRT52n/7EprHS3djC/VamYcevI9gIILT4cYfDFKzq5imTaFQ4tblc2zfvv1eCEi9gN/rw7INGhtb6e7soKG9Ef4pEezmyC227dhOcnMTV3WN5vBWls6N8NZLP+CTn/kszU0h5sau0Bx0YVQyFPIpDuzcQa1UR2ro4czVywz1d9Ez1A+IeD1ePBE/SkBlZmaci5cvEXKHmJ8ZZ2DndpB0Ju6Ms5Fe48aNC5RWyzz5nlMklzeo6SL1ukhJUMmm61TrBk6PFykYplyrUJdF6kCurJPHQjRNSuks9UqchTNT2KKTkm6xWUzh9bgp1XQ0nw+HoiDpFoYoIUgKlUqJpqZGarUa5WKG4aF+0ptJjGQCze3Ap1g0hTwM9fYTCQTxOcNUrAqRhhDFTAJN6kU0DERNolrKY+o6HpcMRhbJuPefejwuVFVFlmUURWG9AA6XA4fbTVWv43DdY7j9S+vfiJgKGBaI4j+x6wHTMhFEGcOyEAQRQRQwLAta1e+6AAAgAElEQVRRlKlULURRRHM4ESURo1pifSNBRU9Qq+Xo7GhjaWWTui2wHIeLl8Y5tCvIfYd38M3vnEOviEiigGXqeN0uZNPENgwE2yTaEMajCmRTBsViAadPAWzq1RqqrLzbhRZyeTbTaQRBQJZl/H4/inLPCtALJl6Xg2qtjMMp09DcSFmvkq1amJKA5nJiGjrSP6VMBX0B5FqGhekkpXwF0zRYjc0Tj5l4lDC1WhrTqDC4Zw9jS/NcunqB7r52GiJh8iUHX/3Kq2QDNWRZpCrKXLtyjc987BPM357CpMTBA4fYv3sXt29cZ/f2Duq1OE5rF65QI5fevoopSCQ2MjicfpyWiFXLUKtV2LdnD+9cu0aLmMKrOTBLNbZ1dXB3Zg5R6cTjDKHrEsvxDd7z4fdx+sffYnz2PM89/z40j4Yh27T2dVFXa1TJ8t/+7m+IhPZRqRoMDvWxcvcG5678lLIvgCFXePL5R+jZ0odVqCA2edGTSd4+dxpV8vL4U0/y0ksX0J0uFtM5fvN3/4R0tsif/9Gfkp2bYj5do7q8zEGvxAdPPYtVqMF0FlFVaG5rZ3phCX9jE8P3H2Xk9jitje3YZgFNqNO1awetw33YdZAkiY14nKaGEGffeYf5uUWOP3yClo429HyOdDrPz33uc1CrMvLT14m2hTh//i2ef/5nSKdirC5O4GwMoCoOHA4Xg1u7MMwSRx86SimfYm1lFa9XI7m5zv7DRzj39hvotTodHR14vW5WFxZIbGyALRM7F6e7JcInP/xRzv7Nl8jXKjx8/242Nlfx+YIcPbSDQqbC2cuXOHLiMA/ef4xQUxOq7AHL5it/+HmK+QqnnjmJLeqoqSrltRiTFYlb1xcINTVQwUQ3ZKpCALlvCyPpGvHNMv5wK/MbKaaSGVZXVpieX8TpBtMCRfVSLNUxzRqWJGFLKrIA6DVs3cLfEKJYKN87xTVHkCUd0Q5jWwYOh0pAFfEH3IgiNIQH8bhdhHxuvB4HPpeLcCjA22du4PB50FzOezu5gkRzJEIln6M50sh6JkFTcytmXceq6YhAuWjiCYWxRQELGz/tmKZJVZbJVqokEgk2NzdZS+RZja2TyeewBKjodcz/Hw7o/ybE1BbBVO17pFDbQLItBMsEQbk3gbTvXfemkSaqLAA2pUIWAE0RwSFSrFioUhhZllFlE6MgYtsqE7Or/NyzBylfW0UpgOjy4FRFZAHymTweTUYRBLAk0qkcm5aFy+XFtE1UW0aVVQREdKuOoCrULBPqdaqmjtt9D9aXr5SQdZl6vY4sOrGNCnt2DNPkdxFfWeDogaO8eXUGU3ci2Q4GeqIsreUxpAh1KYfsUAn7ZCSfg3Q5Rsko4Pa1U9XL6LbAfUceZnXmBqInzGrKYmF5HlVYY8fQAGdGr/KBn/8wGysr6DWd4fYdrE2s4zQ1DvQ3kEjGyBT6sP0NtJoiK6M3SeYy7Dywg++99n1Wlpfo7WwjsbGOXJQpJtPsGN7G3FKChqY2AprF5OwSTk8YTzBK+2APLV2tVGp1jh4+ydTELK+e+RYnHt/Dmbfe5p2b4yQrZSavnONQyxATl2Yxgw7c8hByuYJfLHLp0gXy5Q08AY3WBoXNKYmbp6dYHdkgEFBpadrOxK0FrA0fLYNBMlYO06Vx5swdEkmTui3zwY9+nB+/dZrk7CQsL/LCY4+SWV0iefcWitPB3ZsX8PQN09bfQ19fL36fnyvnL9DW2MyZ119mcPcwC6vLVEsVKoUCuYRJOp/m8WeeoFircPSxk7jujmI7nXgVB4rDAfoGd86+SUtXG86oh8X1JFsPHcTR2EZru5fazDxaIUHY5cG2NZx4+e53XqSxsZl99x9haT7B/PQkjeEAmdgP6dh+Hw5N4vQbr3Fw3y627tpKRyKOp8FFfmmFV77+Xfbv3sORB48j/1/MvXeUZVd55v3be590c9Wt6qrqUJ27FVuhFQgiCQQm2IBJJg04wThge/wt57G/MTP+/Hk5ezyDx4IBYzBoTBDIQoBAqCWQUGqpJXW3OndXznXzPXHv/f1xqkotG9t4NOtb7LXuqntP3XPvPek5z/u8z/vuUgEWzjGM4N4vfZWh8Z1Ut2xjx76dHHvsKHGcEJTKxKlmebXBvl17aC52OXTXQ+y//mr6YpCOEzM6NMrR489w6NgRjp6fot0zhH1NVPIwxuAKnyRKMcZi16InrzhApBSlokcS9yjXynjWxXNcsiimEhQJvDqe45BWh9m8eRRHJ8gk4bIt40TZHDLwwPeQrkcaZ4gMRuvltUIdgcAl6fVpxhmX7tlBkiQIIahUKsRxjJJQcAIa8w1IJUfOn6Y+NEJQLNDo9zl6fIKJyUnavS6LzQZ98WwBkJRyw6GD45OkCUoqXNcF5ebLdf954dgPBJhiLawlkrAWawXGAML8K6s9ezuxxmxYpxqNBlmW5Rqr0UxOTzMxcZ7xHWN88H2v4m/ueIJut0+5kGspURRRrFY3igeUUrmfVQhWV1dxXReRSTSaNIXBwUFca1luNfI7XxRRrVZpt9sEQUC/HaJI8X2flZUV4jjm1ltvJUmg2+0wPT3JNddcxbnJ+3Bdl7ifUqwF7Nszzkf/x//kvf/uR9g2upVmw5AJh2ptjI9+/DYGAsFCe4bmCkxOhOwY9fj3P/2jnDq9wm2fu5uV+TkGfZdXv+iFXDG0hU997FYcVzMyvMorX3UTR49+h1QNUKuN8dJbLuHMmTP8xHvew11fvJ3pc+dwwoytu0foC8nCxHkq9QFUyQOpiOMYqSK63RnaYZerr76MXnOSwB3hqst2sNJa5uTThwlbK8xmU/jlKieOPsNgQ/PWt7+DqV6LW7/wHYpK89KXvJyXvOwKlltzHD3xBN994CmkDYh7LiYRCDtIUSyxZWgTN15+CdOLx2glKXE3YmjLCPb8SQKT8fgD38K0l/nxt7+eAyOvpjmzwP5rrubcqdMsd3sUR8dpNptcVa9z7PRJ5ufnufHgddTGdxDGEW6xytTMIi9+xS2cfPxx6mMlXvRDr+GB++/lzIUzbN65jUsu20+9tgmZpNjEMrpjP4XyElGSsGv7fi7ZX+DcyTM8ePc3OH9ukr179qBTj8NPnCMolfEKAVdeey3nzl5g4ujjXLN7nFffeBWriwucPvkMTD7Ijkv289NvfxlEPQj6fONLn2Dn9h0Mlqu8521v5uFD9/HE/BStsEcJjzjKkM4wvX7A4kSLLbv34m8dor20jFMbIIkS/MIIT80uM7tqmF2I+OyjXyDDkmCIVjK0hE4G1aEBcBVeCQZK+bk/M71COfCoDw0wvm0HaZoysmkIRyocafA9l22bt2BsRrvZQmSGYqGApxwkgkSHSFeC8UjCPrVigs0GSYHMQBJLpA0IXI9EeXS7PQqFEllqkDKgXhtmtdmiPDBEkiQ8fOwY09PTzM/P04gjev2IfmKINLiOBJEDpVAS4TokOiN1QF7ENjUGIQUg0FmM5+X5DeWINXlO/xN8+beOHwwwBbAagcAYAZa8GTL/Mve+GEyNyUVkIUSuqyqFJgVXc3ZiEuV4jG4t8ZrXXM8n7/gOjhOgtSbLMgKlkFLiKgfHQhzHdFvtfMKvYol2u43JLLLgIKRCKUFjeZlyMddN17XSoh+QJimO42DSPIG2srLC3NwcmzZt4pmF8xw7/jSjI3WEyigWA/r9hO1jY0xNnmN+rkDWS0h6CdWyYlM1oKYCjp06x/xSzMnVkK07N3FhepZatcJyM+VXf+v3aPd71IZ8dm7fRXtlgTvueZCZxTaRX+Xl17+QV968m8NPf4dX3nIDze4gDz50lk3HT7Bz53Y6rVXe+cNvZPLkGe6/+x4mjx7nl3/hQ9z2uc/i2JSiX+C7Dz7Bq159CxMXpmm2QiqBy+rcDGbLICv9BrMXjvOO99zC4Sfu51U3v4wH7z7Cjl27aQ4NcMVllxB2Yx548CEG6yP0V2bZv/9Sus0ei7MrtJcjssjj9T/0w0ydv8CTTz7Ja27+IU49foRqUCEpRjTmlki9gIFqjYn5GaamJrj+qkuZOXGW973j9Vx3+U6OP3yYy/ZewcS5aRoZpIUqXnmAVxy8BgolDrzsFRzodDj25JN8+lOf4YM/8/M8ceJpbnzpzUxNzNKLNVGcTwuybXwnu3bvpT5YIRgdZWl6BhMmlIY28YW/u423/uzPsvDoo5x68jjlQpGJc+cZrg6wrVLG7XbZset6Dl5+Lf20x8T0BIfu/io/90sfYu7oYUoy5b6v3kGlXMTVhku3DXHi8N3MLyzx4le8kjN3PsK+vTtotzW9xgLHHjtKMSjgGEngV2hFinYUYmVA2pWsZJrHZp7mxMQpFuZXmFsGJPgBOA6o8ijGGFpdQaFQxPU8Uj/EKxUYciXKc6n4BQILUfscNx58IeKgYnRkM1pbVlYaFL0AncZEUR9fSkSWEq5MY2WBAoJyrUrY65MkCSbNGKsXCW3Car9F2O+ySoY7tAeURCqBp3x0osFApASqUuD8zBwTE1NMTc4wMTFNc+3S9vI0ClLmnGvZ5q+R4AQusckJkKNcpJQkYQgCcByc7Fkytu4OsjZvbLL+vNfr5TbMQoEwTZ4XhP1AgKmwBpmmgEIpF+F4xGmIq/6V9Z7TCMXmGbpiQBRFRFGEsJZEZay0LLXBMeLwHDt2+AxXoWdcFJZyuYxN8uxeGif4fsDIpk2kacry8jKe5xH4PviQSYvWKcVSQK8p6bY79DpdtNa5huv7lApFPL+KI4oMDQ2RpB22b9/OxOwyrqcoBSUuvWw/C0tnSdMYi2ZpfhHXKXBhapnRAZ9L912FjReII82p6VV27L6cMA146smjzCxNccvrXka33ePRBw7j+PChX/wxPnnb15mYa9Bt9qgUXNxNO1hcbnPnoeN87q7Pc+BKh4MvOsgdX7uPc2dCDq6+AkYjRNhl8tgxLt9xCUdlhRe/+s1MHT3Dlbv34dcCTsyfZ/f+nTSbTfbu3s3M1CyDlSJX7d5Ob+kUrrOZekGyOD3J9PkJwo5ltD5Mt93gTW9+Pce/8Tgzy32mZ5sshgnN+fPUfJfhWpnHvvMw6YpmW3Wcc0+eZNeOnRSvcKEtuP7yq+k1emSdLqWgRDsxmBQmpk8zVi9z6tvf5m8+8vt85947+Ou/vI23vf29HJ04y4FbfoSdrZQvfeF2njxylEv27OWpw4exRQ+kwHNchjZv5vjZCR5+7Ek+9As/w/LMPAdf8VpWpqaZvHCOE0eP88qXv4TD336QLIwZGBvlmVMnueLKqxnZvI2j9z1ItVxj947LGakPknZSxgbqDBYKWJ3hpD3ShVXazSUO7NqM2T3MNz/zEbbtuoRTZ07iV2tcmJ1lz549fPfp0+BVMPUSj0x16DPEcqvP7ELCmWMT3PLil7La7TE5Oc3k/AUmVxu0W6Bc6GpIfJfUc6gIhVuo423KqNQGkI5LuVymgEYnKW97w2vBWHzXQ1uTVw4piPptttZrpK0mWo6Tao0BdLeFtpaCY3BNROAJym4RRUan2cQvOFjl0Ol0sMYQxzGFQoHacJ0mDokrKI3sZPr0aWa7IQvHHuP8zBSNXo/YWtCg0xTj5FWPQiiMzgFPW4Xxfay1JGtJZ2ty8BNSYGwGae7dVkrhOT4i0qQ2QZBP7e4IRWoygsDPZT/PQymVP78INdbL1wFW263nhWPfF5gKIS6QlwdoILPWXi+EqAP/C9gJXADeYa1tiBzh/gJ4PdAHftxa+/i/+h1Go6REa0OaxCjpA/H3vSHrjLTX65EkCdZaPNelnfRRxWEcVSdJj5DFgoLQNNOUJEtxpcKxuUSg3Lxz/8LsHKVSicFqjcXFRYaGhrASPE8iXUsYdrBWE6wlo5Tj5GxUa3qdDp1uis1atFo72LptmKm5eXbt2kX2yNO0wgaHDt3LTS+9CteT9MOYwBEk1qEPnJjoIdwyJl5hYv4cfnkTpydnKJardLshm8YKnD51jF67xwd++m3MTJ7knnu+zJ7dYzQbbaxx2X/JFXz2H76CEC5xM2PXNsUTpzLuefAM17zwxTz69Ke59U//inf9+Jt40YsOUKsP0IsTmt2QIC2x2u4zM79IdXyQ1/3wm7jn/kOcP3WBxnKTGw5cw5MPf4fxl9+IKkjmZzUz07PMrZ5F+S6Li4vUy0XGdw7z9KmnKQ8WufTgdRxeaDOiPPZcupdzTz3G8I3X8YYXvgTpV5mbuoBSmpHt4zx+3yKPfuOb+GWPLNRs3TLM4NZhjHQpDsTUKwFnzpzhr//L/8ODX/4qu/eNs/eyH2Nw8xY+/5UvMrFsGRseZ//e/Vx/9ZW0Gy0KhSK7D1zOcqvB+Pg4Y9u28eRjT/H+97ybL3z2Niq+T/OLX0KWXDaPjlEJBDrscNOLbiDudYiiiK2bX0R10xheeYDOUpNes8+3vnUvN17/Ah46fBxSy1vf/FaOHz/G+ROPUCgWufSKyzn38BNsGd/GbDtiRpTRYxWeOHmaucWYY+EMY8PbePLwceaWV5laeoxYCNxShbnFNqO1Qb776a/iCZX38Q08itVR6ptK1AcHCAKPcn2AynCNcgz9KCbTllJlgF7Yx/ECqlmHbreL6uZyk+sHeL5HEPeRnsRkPTqLXVxtMIUahaBCP0vpJhlGSBy/QioEQbXE6PAQ83Mz+G7AcrdNr7VKs93iwtQkmda0e11Wmwmhckhdh8gYhFCQWgZcSIwl1CnG8VDSQQqJtn2ElQixHq6LtfJEidZ5BaTjOHn0ZzWOtnjSxVEGRwk81yFwPQrVEkJKEp2XNwopSdbi/Lxh0Vokqw15tiwfafb82OjF49/CTG+21i5f9Po3gHustX8ghPiNtde/DrwO2Lf2eAHwV2t///lhLTZNsI7Mt9Ut5Zn7792B75/5iDzMz5L0uYzV8Wi04E/+5H/wsx8coVyu88Y3vIFbv3gfiFwvcWQOxp7rkvZjlMgn6ovTiKHBOo5U9NM+Bij5RRYXF/GEII0MxWJxo0GLRpPqXJtx12xWSikGBwdp9lK0BmE1J04cZ3jEp16v02z2wVP4pQG0VQTFiPlmi31jo5SGF7gwswpCsLw4S8mTdJYN5WKFslPgvrsfYer8JO98580cfOklnHjmNN/57lM89OgRXM8hiTVJ4HJmrs9v/Ief4OOf+Tv+8A9+k6dOd9k35rJj8xbm5qYYGK3zp7//l4gk4KrLr+Mr37yToFhjcaXDl+76OqCp1+tsG92GryS/8ku/yOnjjyMHDcoZpVQe4Zd+71f59Mc+ysHrXsn93/pfrPaanD52nH3VXRRmp4mkgsYye3bUWDp/knsunObAZdcwsmUf4dIcga8JbYeD+8Zh7yV86f77uP7aFzBUL7EUT3DszBlEoYSI2uwd2cSDd32DXVtH2LJ5N91SH7ltD294yzsZrG0lbiVMHj3Mfd96gCuuuI7FsM3kofsZ3DJKbWiYRrtDreTz6He/zQ1XH6DqeXiXX8aJc6e57oZroVoiWVpgfuECxmZ4ieHk1CTXv/xm4rDNAw/eT1EV6IQRH//UZyhVBjDW5wv3PkqSpDCym1VtWZoJqY/s5G8+ey/zi4v0y08jHBe3UGZxeZVMQzU2REmCVyxSG97O9pFRNm0Zw/OhIBzCZptKsYQRkBhN0dYY9D10t4GvEhyh6UxewCtW8JVDkmkGVYmyY4jDFlYW8X2XTID2PHpSIWODKgzQS2L8+k6UVHjSIer3aUcx7ShjanGRpdUGzW6PRtRDGE3gu/S6HQarFbCWLJQkRhNmCW4hwDgefTehXHYIgV4jQQEeEFuXGEuqwDgCbSwWjdDkc4YJi5IuQkqUcnCFxS+XNzznvu/jui6rRAijkTbDEQarU5I0Rno+RkCqNEaAFRCEuXwnLRv5FKUUCdEGPAjxf85n/3zC/DcBr1h7/kngEDmYvgn4W5sLmg8JIQaEEJuttXP/3AcJo1FJG5P1CUqDxKaL1gZPFonjGM/LiblYAz/jKiRrLfq0QUmJ8gy+KwiTDHSMazJEahgMynTTFrcdepRf/cXfxkm7XHtNF+fvLWFpjF63zbjbpRIIFloxlYIBVcAtD5HFCVkaEvf7uE4++Z5rXOr+IOFqi8Qz4EmKhQIAnU4HYyGL2sjhTTRlBWFivKxNa6XNQOAylxiCcpnx4VG6nZQjp6ZJGh4eSxgj8CPB5MkFrtt1OZuHt2DiFiruEasUqSt0O9NEvRYIF0cpNo2Wuf3v7+W1b3wbf3/4EIEdZKAcooWL4/uUW/O88W0/RKIF5+cSpudWuOfuP+NVb/llth8YZWr6AkNb6lx980v45Me+xW/+0Z/RXGly6RVV3vzW13Dn3ffRKEqIGjSTPm88+NP89z/5JO/94BspDvpMLzaJvT6PPvgA4zu28MXP/wX79h9kfnmWreNXUt+2m3NLM+wdH2JRt7n68v0MRlsYGqrRyiLOrZ6i7yZsuWQXnit5+tGnyJZCao5h/uhTXEj7eFeUqY3WqUyExCs93vbGt7Jr8xiMVbjr0x8jpk/10EOsSoeonXLLvhvoXJim0w4JBjZx9aUH6KR99r3oKu67/bMszU3xyhtex8zyNK5j+O7h+7j6kv1c99LdkK0SzU1wYWqRJ4+d4sd+8gM8/XdfZFO1wqN33cvYvksISkV6xqKLVar7S5w4d45KfYS53jIXzk3QUZJWu4sVHr1+SqU6QOrXGWnP4QeWwYLD5ZddSXWgzuJCg7GxETzfJU1DqrUirXaTsnI4dfIMW0Y2ExgBBgqZpVoXxP0Q5YLyfGxsqZeGCE2M6yoiY+hlCZkjaCcJg+g8UvMCUgzVWo1eB5ZWWjTaLVZbEyw1V5ldXMinDyclNiE4FiNgeLiIW/bo91OSNMIvFOhneXjdLxhEArXSIKutHl6xSHmgiDVdXAO1SoE0zZsKpWtd4aS1uDrGUw5uwSXMDIVCgVKptNGHIx/5c6VAKQetE7ROKJA9m5UHpPBwggCpJQhwpcIKcqIkE6zMgTRbSzClOiNQwUYXOq31BnN9vuP7BVML3C1yGP9ra+2twOg6QFpr54QQI2vv3QpMXbTu9NqyfxZM86lI8g5Q6zsqSRLQa2xTJ2sT4fGsZrImREtHIKzFVYokSej1emRZlmfuhCAKe2ij6fSg0eqzdccm9u1zKMi7CJMuARqlE9Jel1qxRiGweKU6jW5MFsUoq/E8l0QnCOmwtLpCrVjGKxYQriWOIqQQhGG4EZK4hQKa/CAqpTDG4Ps+nvKAhJXVNn6hyJaxEbAaz/OI4x5ZKlBWcOjb3+bgFTUu27uLSrlDaqZY7vSRJUnRHaDTDUm1wDOS8wtdttYkn7/9SyTGMjE3i15L3UlhKVXgj/7sL7j26oM4rscf/vFH+a1f+3lu/eh/5Ct3fZMD127FLSle+0O38OmP3sfJxUW2juzizOI8H/r1v+LKK3YytHc3W3du59t3f5WJa1Z4/49/gEzP4Rd8qp5H2S+yMLtKo73M6XOLNLtHQEGpUmZm5jBbN++lpw1uUCAxhpV2l+V2k9UopLp1jMGBOkGpCiZh+/adFEYdjp04z9bqKCOX7mQ6PYm0FhMvsBolLHS6dLtnaDwwy/Jyj5HNw9SdjBfe9BJ63YR66jM/4PMzv/pzzM+vom0fV1q+8N//mquvuIS6W+DrX/gUquzyjp96H7XCC5k+e5anH2jSi2LGNm/lwkQPYYf41j88hK3spd0LOTXd4fzhQ5yemiEVEmVLLLebaCHJzAKOkdQrNeoDDpu3bOGSfZei04wgCEBDxbYJikWkE5BkKXGqKWzdnGuCaQJZStjpUAkCRGq4dPelKMdFW0GSZFhH0ogyPLdIlGWkwsGrFukbg+/UWA0jUuWx0o7JEBx56hka7Qar7Q6t0JJaEA4kSR7pKtdBC/Lst4aSzSiWApT1KRUUQcGlGLhkWHBdsjRFWA1WIKVACA3WEMd9HJWhZEa2BnLGGFwlUSqgUFQYA8Ky4csWQqAQKJ03hU+SvOxzfVycMFrvJuc4Dv0wWdNY5UYEau2zkaiUMp/lLcsQa1WUxpgcT9ZGz0YbALpeBv7c/Mv/3vh+wfQma+3sGmB+Qwhx4l947/f6Vf+ESwshPgh8EEBJQYKi249wTA/XC0BneIXiRklpluV3JM/zEGt3sCxKcvrvODhSkEUJJssz9J7nYREUlMJzy/hBj06k6Ky0cR3J5mpKd7VBqVhjAI+Kr6DkYjBMTZzHKVSIen0CR+EGHrXhOlYKvDjGGktiMhyrcByXwPXottq4rosjJJ4fsNDtUq/X8f3cYlUulxkoVTm32sTxHIJyFbfTo+QrRGYIwxQhXTr9hKePncEpVBiulTh9bppO1KI0VOD80iSuLFIsDaLjlF2XXsrc2ZM0miu8893v4u3v/EkK5TJRnCGFxlMp+6/ayU994AOoQo0sNqx2Mz78+5/iupuu4T99+ENMTnydR+67i/HRG7hk1za+/uQRji+dQdouwoA7ldB65ghjowFpr8jH/vZrtFtTfPQTv0V3aoLlxR7T5xbp9H1e84bX8LoffgO/8+E/wPYjBis+v/zLv8jtt3+NTi+l1WwyNDrG2E0vhpUlEHD7XV+lKmJGNg3zwHfuh9RSCwbYu/sqDt15N+kD93PLz7yCs7MXqFd8aoVN7Ntap+45hDWPlx24jG4/xI1XOP74Ua69+WbmHnuS8X1j3PHVv+f1b3wLX7/7O/RDwflTU6SthLTXJzWSsKt5+LFTZMayuqzpM0inLXlqpcGTR6Y4evwMvu8xuZJQGajRDPtESLxiibFt2xhwKnhDEXv37qFa9EnbLYarVaKVScpBQGBTSkUHTyYEgUvqlClXaswsLFMvV2ilPUJpkeKiMmoDWoPKfPwgIJOSTCr6JqTTD+n2Y+bmJ2j38htSo9smjsE3uVNTuC5RljON2GRoJXCCArFMEZ6LtUAaEbvOhnUwp2+QOJJ+v4uyIHFwhbheqRQAACAASURBVMQvVLG2R71aBWuJw4gsTrBaI13wfQdhDNoYpEgQZDjSxS24aANIRZRkkBqElAiRs0HpKISSOMLZ6BZ38ZDSWQNCUCrPpVibZ+3TNEXrZ/sbG2OwicEIyITNbekCZGbWgFc8p+l8lhm0Xv8+8/8vM7XWzq79XRRC3A7cCCysh+9CiM3A4trbp4Hxi1bfBsx+j8+8FbgVwPdc6xXKFJ0AY/MNr1XLaGNyLUUJ0lSvZeUcAinxPQ9T0njKIQpDbKrBGLIkwQqBAYwExyak2qMTKr51/+N84D230O3O8ju/9u/5xQ9/HLBUi1VKgWAl7JPZjEo5IEwySoFP0fMoupJOp4sWa3dWBIHnUyyvNa+2UC1XMMaQZRlSStI05YEHHsC9cphOc5nipl2YxNDvpXhFj7/8yMd4zc03cdON13Do7ifAB6TCOorIRjjlQU6eOY3re3R6XbbvvBSvGNBrJ7TjVQySx596mqI07BjfRm14E6WhARJ8ur0WY0NVdLfBn//Xv+Dm1/wY7a5EyAKBhHZfs3roKU688z/w3nddyS0v209/dZH3v+tlPDJ/jplZcIJNKB1ydraHlIr55jw6M5ydOs++7WUa/YxSsUKhVqZY3UonlBx58jh3fvVpKpUaaVOzqVji9OHDXLpjG6pQ5u7Pn2Ti/ClMZ5EnnniSiel5Nu/YST9OOXX0DAcuOcDQ8Bhzs8tYT/EjP/4+8DNmu4fRWrO0sMgWupy653b2j48RSJfvHjnF4lKXN/3kB7n3K/fzlfsOc3D/XtyC4cBLXsjhZy5w17cfoT68GyuqnFyMcZEcXZCcnrrA733pLOUiFFyXuShFCPAUOI4EFAf2X87L3LwxhlUSYyHRBtfz8Lp9rCpjw1kqXgXHiYlmp4lxScOQsufgVcu4Xh41daXP/PwyvX5CS/dAKBLPIY4MjuPSaLSYmppiamqGsBeRGojIH5q1wFdILGAECN8lsQ5aafACoiRDpwaLWqMvPq62mJ6h6PqIVGCERVuJSixCaLTNkEhc4ZD6kmIxIJCSglRobVle7hLaJqVCkcDz8N2AcqmGyTKKriTrR+gwxHqKzKT4jkQJS5IlSOViTYqvBMb18pDaGPpRiPRdXM/DYZ1dWvr9Z03zRufNg9ZBdr1vByLbeM960llrjWNdUBJNDqQWkNYhSdJcXrh4Bg8hn8NMucjc/3zGvwqmQogSIK21nbXnrwH+M3AH8H7gD9b+fnltlTuADwkhbiNPPLX+Jb00/xKZl6SR2xSMMRiTJ3Ks1mQ6oT408JxO/NZoMBmu72F9F2ldWq0WmJwJ5jvUYnUGQmJEgdVOyic/fRvv+8k3sjq7jOs69PsaVS3S6rXophqHjFQrHKeAEhKsptvtkllJbaieV2Vog2OgudrIO0gplVuoiiXSNKUXxxsHefv27ZxP8pNEmrzKQ6gCxnQpFH2qFmKriSLASSjJAkJ5dMOEl7zuDTzy3ScoVQY5d3YSHeWs21gBUiGEy/jWrbz0hQcZ37mTRGtWwz7dKMJdtVRlgvIDgmKJVhQTxhkRCcpqZGKIen0ee3SaA3s3MVwuUB3oYzqr1Krj9NIYIyUZEJsE6TqUhyr0VhMOn14lkg6JUUystvEHRvncbV/mtVxDvS6o4PHC625GRRFzZ04xOr6LJIsZrZWpVTyMjrjqwKVcevnlDG4aw9Nw6unDeMLnxNFn2HflQWZmpqiKCgQejgnQy4p2J+Sq0WH6nT6nT54m7GtWWwl+aYxbP3snfbdGJDNOzzTpxguIbcPc/Q9Pcex8k2BlmguT80QhVAJYSh2E6+BUvTzUNQLlpASeg8kyapUqWZIyvnmMQtTFV4Y4DpHWUlIK4piSa8ikoRuHxGF+3nrFAp1MYLUhMwbX8UmUhzWalb4liiDMBKtTiywsrXB2aZYwjNEadJbXrljAdxWJNcTWIpWDlQqLJNHPhqtZmLtdpJT0dYjjeHjSw1qBztZABoGSkiTt5+3UlaRYzO1CruOghMSTClcqmk6ah+LG5ok0I/LXXolubOiGEZg+A9UaWZzQi3oUXZd9O3dybuIsfuCTYtZCfEGiNcp1EVYgU5Gz4jV7Ui+KyKzBW5P2jDHPCbUvBtN1IBRCkF1U9ylE7j21VuSRqxFk2A0wxYoNIL2YfQrXyTUHwH7PQPp/b3w/zHQUuH1tQx3gM9barwkhHgX+XgjxU8Ak8Pa1999Fbos6Q26N+ol/7QssEKYGV0qksBSLRQqBh1qrUsjvWGbDvCsRKEehyX2fYbeDsJK4H27sPCsgMwYMuYYoC3z5zvv5w99+B3EcsmmkzsJyj/GtW1huNKhWilib4cuQwCtTrI3QWFxGoZFKUBABQ5Uaq6uroA2OEei1jjPWmLXa4G5emw8sL7cZHHI3OtY0Ox0cIUlSS9KPqZV9PM9j59Awl+7Zw8m5s1i3SNq3WOVy5dXXcX5imseePIEUPqP1OiISKAFSWaQSJP0Onc4y+/aMs7yywuxih8wtoPwiUdLnlTddw+ve8COcn0qwSuEEZYyxYBMyDSsNyxdve4IfeeU+6qWEbds1//U//wo/+5sfw3FccCSFik+YddCuYlXH+LVB/EJCK7EkyuHpmRVmWyE33HQQv6Do92bQUZmqK9laH0MODzHfbjM0tJneUIXN9TK1kTq6G7Oy3ObIQw9SKw+ze/seGisNTp44w1Jfc+DGvZw58wxnTh/nitcdYHJ+mfLgGItdl81j47RNl9Uk4XyvyZ3feIyBoQH0SJWnnplkEPhvf/4hHj76CF+++wSJo0g6XfqqQHVrhaZJKEYO2kSUfcWBvXvYWinjlQpYbbCZplII0ElMb3UVsWkTcZKiCvnsDxiNyTJEycMNCjhxkdAv4lfrzE3PM9+eY2FhiWa7R7cX04/SPPSWIJVDlGa5lxNI8kpKlAS3UMAaRRylIJI1kTGf+twhByFjk3yxBV8opLUIk5sIHZFQ8BwcIVEywHEc0sBDSI1OfQQGIQyJdDFAYi2egNhkxCbFzXId0qDAc/LmQlojrIsVFinzkLsdaqR00bGkWKyRxZahgRF6SR+kwfME/SjGXWOOAI5wiLIMrcEIi+O5JEZj02fdNxeH+kY7z2Gm69n4Z8Pzi33mAolEG7Pm7s/3aQ60YAw4zrPu0tSKnJAA8v8QK4XvA0ytteeAq7/H8hXgVd9juQV+/t/yI6SAgqeRSBSKquvhCIeG7uFIiRYJWZprpsWgSppK0jRCigxj8+mapZtiZEoUd1BegEXgShfhugR2BV+soEoDHHpsnisO7mdldY5rtkmajSmK1S104hau00d4VUqlIouz5/IDqBTVoQEGSlUcR1IMPPADwjBGJinahDgOZGkXIRwc6RJ5dZrpCtYkDNcLHOm2CcUYjSxhuCRJlaDRtxw5foZ/9/bX8uoffQFn/uQs/URgvSLt/jIP3fNNqEtqtRKnT51m67ZBoiRBeQprPIxxKZdqNFdW2DY+RHPlAspClhQZHBaknT7vfde7+Zlf+DAuijTJSNI+1pEIEWCkQAddYiSHHovZNLwZx5xl/8gIrUaTpDKMFAFlz1BSPhiJMAIpW1Tqmh2XXU7LeuxfGWTAHuXayy+hGAju+3aBePYY26RiwBZYSSzLYcRScx7pxMycm6Y1dZ7TF57mhhe9mmNHTzNQ63Pq9CzFYpGFJkwtnuT0xHmGBjdRqAwRLncpxIZgsMSffexeOia/S0esXzeKpGXZ1J1BAZ/7/J/yzQe/y3/7xCOYwhBYTdXz2VLwGahV2LZlDN/PKLog4i6e0BTdNkWytbZzmn4Yo1UBWx3EtjOCQoFQp7STkGa3y8LqMrPTc0RxQhhbUJK+zqcnz8SzLCgPT9cuNuFjtSXj2QvYNWuAoMERAmMyAmmJk7z0UQqJyVKEsjhCUSjlDXXWgcZZ9zhnF9t91oBCKRwdIowAbfMJKKWDazWCfDqgNDVoK/C8AsZka4wuj+jyVI5GaxdMRmY1URojpUDrlL3VYcK4z5OnF+nrjAyoDVbZXKuiHEWlWCRJEjqdDqlskooUZA59SWiQjkBpSSYURvkYZVCkKFJklv9mSa55YsBas8EkLTlSirX/JwrWuncg1h7rEoa1uewgECipcITFd9cTw8+CbLPX+7fA1j8ZPxAVUBZIjUJaiVsoEBrwNCgUYadP4AcEng/aEPcSrFQokaJ1iiMMRqe0Oo3vLSRbFyEUjnTotlPuP/Qw73nbjciCy0tufjEPPHiaMDaooovGI4piBgYGAUGWaUql8hpL07R6q/TjCNbCraAyQLVYI4q7SCkI+wlWuSjHoVr08QKfOI7Zvn07JxfAL3i0e8u4JR9jBc8cP82Zc5dRHdhMfUCR9gWxzXB8GBous2fPIA80jpP0GzQbC+zbu50zkzMbmxbHMTKxfOITn+C9738HjoTYRMT9CJ3CHV+5g9SVhHGC9B2MNWhrsVg8G2CExuJw+5e/yfVXvpPhK8cwKuNXfvsD/Pr/+zdo7dJOI5ySIEssl+zcS9WXvPzF+2hNzNPM5mlPnKPYa5NOrbIUtnn3i2/iT//4OI/aM4yPRZyZOM01r76exXCFp6ZXkO5ODl57LUTwp7cdIrIjPHxihn6/j7WWdrvN9EJMW4Iv4A2vfQGvGhvhspe/g0ceWWTBfBtcnx4GGQQIFC6KwYGYrK159LsfYWlxgf952+cYHKkxhsZxJVddvpc0irAmo+B1QFfxlItwirhK4PsuoaeYmJxmpdViqdFlqdmm0erloSt5H1wROHm22Bp0bNd78CBRIB0ik+FcVLm33oM3D99jpJJIm7Mru+ZIcRy51h5O4LpBbgXUZiNxsh4GZ1mG4+QzS1iTS17WxNg4AvXspbweGidJgsWsNS931v5n8Rx3rZTaADJvf9ePNtZdz4Cv+zINGmE11mp8JYn7EQODFRphQi+JSK0k0oAUzC+3aa+2GR/fwtTCEkII4jjGQecZfZNHleXAJYpjrNFIYfPpQ9x1rTfXhNfHOihKKXPJYI2lpln6nG1e7026PjzXe06J+YZ8uLZfjTGk6bOf8XzHDwSYIiTKCXIjsNZYaXEciTA295AKiTS53UEai7EpUmpcJdBpxmClxMLyTH6w/pHFwRoFUiKFT8EvsWm4iNEeA8NlXvzSF/Dw4dMUXAdPVYhShyBwSZIM3889cr5fwFpBGPfxAg8/yE37hVLA3OoqQ2qANM3wAwftOPS6MasrCyAEQ0NDIAXDIyNM9vLm0kHRxwhBFGYYV5Ekhvb8HI2Gxq8owjQhSQ3SsbRmzrN36yZs1uMlN93AyQvzzwHTMA4pCXj3u9+NcvNzMbB5mHrNVaO0201Wwg6FYpFeFOH6Xt4JyFpsJtFSkCFYbsU8c2qOg1cfIIx6HDh4BVZkGKHIlE+nG+IBOjNUB6ocfuARfus3fx690GTLli18+ev3E++pU3Th0UOfgsJW5pqWbrLMajciTDSnT5/F+DXOLPX5ow/9DishvPI1r+D0TItDRy5QLbq0+imegKDgsBxmDPo+R87O8aKbr+Dzt9/J8nwBx3OJ7VqWN8twHUPJNThhkz/+g/eizApfvfNzXH3pJWRmG0E0Ra1Wo91uEAQBpVKRSqXC/HxCoxty6twFwihhfnWZyMkLZIRy6KYpFhfHKRJn3fwcLBfphH2Eo1C+TxL316p4BMLk2qbn+Zj0WYazXmrsSIk2GUIaKtVgQ2dfZ14XX/BJEhJIB6MNqTFrLhGBtzbbqRACASglNpp3XFwruA4UQgiwkizVG7P/GmPodJK178pZIkhc18faZ2cIXgdxrTVWSDAaYQ1pltsSh2uDTE0ug3RQnkIYUJ6L1RlZGiOkQxjlRSvFUoW42yJwPVzHpxeFCKMpuR6+o2nFOaBueH5snvPY2B6hNnITZm12i/X9t77vUms27FQb61k2chfrXnV4tqfHut1qYzzPYqgfCDBVUiGRCDIC3yHsd1FBGZsl6KhLELh4ypL2QgpBgFWCIPCpFAKWFlfI4g6+75P0QmDtBFY55bfojQOhlE+7FdLrJAwMJOzZs53LLhvnoYfPYsgrKFpRRLFYZKBWp91uE4X5Hq4M+CBcOt0e1Vqdfj/CD8pYJMr1MBZcz6U+VKNne6S9VYbHRqnWB2k22rz5LT/KqelV2k9M4pYKWOWw0kyYmF5i5/Yao4OwEId4XgFPQqPdYf+OCk+fW2B4qIo2Ee9674/yD3fdC2iQDsWgiEjaHDlyhLe/78dIUvCEZctImf/yf/8ub3vLzyILPonRSM/d6IQlhEBmoESuJ7cSxee+8iAveflVjA27bNs0TJJYlJthVYGi7+BYh/nlFQrScstN10MU05dVZvoRwa6XsuAbjjz6IKpf4JtPP8lle0Z56YtvwC1t4WSrQVPBak/Q68fc+Ib3MbMyyd2PnGRmsodXHiBzHBwbkxmDCYpskiuM1Sp0FyZpz00g2iukK5LhIOKyA9ewbedudBrRWJyi05jhP/7yr7JjV50vf/aLtCZDiskwU1MNTjt9wskVllebpKnGAkEQkMQRiYEUhwyFkQUcnQISnVmUKqKtIcwyhKOIgTCK8gbm2kCSAk5ecumIHPBkzuTcYm3jggc29nmm8/Nz/WLO9UCxAXTriZaLwXA9jF/3XK53NLPWEkXRhkcyle4Go1wfF4P0xdns3JcpEeR6IlYS63Tjdz139g1BSoKyBmUNDrBjZJTVuQUibRBWUgq8nGZnmoLrMVgrsDA7w/jWrRvOls31gbVKJpew16NWqbCyssKu8W0st3o8cfo8OBKLl7NQx9vYfxusEjaY5sX+04unh18HRyEENtMbz9e7wV2c1Lq4Lh/ItaPnMX4gwFRi8WyM0SlOmjIYQHN5kkKlwNCAj6sSHDIGqg5ht0WcWrrNiKU0Io0NnizkVQ5rtqSLHWtCJgiZUhvYRNKMiE3CN7/5Td7/7hs4eeYxnLSHayKkUyCKbM7GMkOz2UYpRaeTM0pcRbEQkKQOyytNfK+AJxykzjOCCoHjuCjp0WjNID2H4ZFNTM/OgKv4tV//dUSxjl9QtHtdQFHwBKOj42wfT/m93/05fuL/+giZ8ellMDfdZWWoxPRCg+uuv4HN2zYxtdjE81ysddFWUiwW6EdtoigiTtaqxKxBhynL86sUXOjY9X0M0oDaeJ2CjNFAN0k5MxPTTH3c5T6+bfO7v/FB/ujPb0U4hiQRWCNo9focOdPgzz/yn/jyt+/FLQruve8pPv6ZexisBXRaEWUkL3v5Qfbv28td3/ga11+zl+GwzNlnJvnSN5r45RKNbo/BQUnSN2yujZEQoZQlXJuKJssi9uwfp14eoOpvYXSoTq/VpdtwuOTaEsIpMD27RKUgeOzRpxiuwNjOEf7qb+7gI594lIF6lYwe7W5EQ8bEqSbVFscv43g+ba1xlMY6EqSDsBaTGYzOrXiOlGgd4wiLdCXWERtNMtSaWVxKia34a93ODGQJShgkGuVXNypr1i/4/KLPj5Ex68skjnIQ6LXlZg0kDFoKdKbJshTbjzdYpeM4G+/LgdKilAST/aMuamZtnRwcM/2spchROaDmtj4HLrpicklAPQeU7UX/18DWkTHOrDYwpPhCoaMOyqZsHhxgeHgYoTtsqgbEcQcrBL5SDA0P0VxdJep12Lp5hG6zQb1sIQ3ZMT7G2bkFVvvJmgaeIVDotW1YB0BrLf5FcsbFDFMAvu9vgGmWZUgnlxikXJdR3OfIJv/Y2/p8xw8EmFpj8AW0e2208KhVi1x+/VWcm5tEScni3Cz1So1ut4sUgiSSSKVxlMAvBphUkEYJWWYoFgOy9CIbhMzwA0mahWRRSLkIp06foN/Yy/5d+wjUIEef/DuiRBNID5TYmM8pSVJcN9c9Pa3odGOazQ7lUhVjLJVCAdcTuQsgULSafYzMNaheEq4dPMNdX/sKu/ZexqEHn6AfasBFShdsxuLiMq+7ZQ8iC8g0FKol4laL1UYf7VXwywOowKNcLsLCErAWupjc5aCB8+fPc+cdX0cgKcki7377W/i7v/0MUgRI7Eb2V1lQZq2qYs2vZ2WG4/ukIuTjn/wsn/mTD/PQsXPcdON13FpwWWj1KARF0jAD6eSh7ECNlx14Hce+9UUCE7JjdJhu+v9x997Rtl1XmedvrZ33Pvnme1/Ue3qSZcnPsmQ5y0K2kGNjwIQuKGNoNy5ocLcpKNo20HS1u4omJ0PRgGHYZGfjHCRbcpSsHF7O4caTw85r1R/7nHPvk91Udcl/aNQeY413x5PeuWenueb85vd9s08OfOCjH+Rj7/9PfOh9/4Qp4eqF3XihonOyw1UHSyi5i/2lAJWus1SboWxUwFRjSMVhMBgAcGnQ4skTp9i1MMPmIOf8ZsTZTZMn184TxwIpHBq+oJPAh//mL/jLj/+//MXH7qNvu+w6+FK+8fC95KJPVRXnjAClIpJ4XHarouutxxmL67tEqshWTEOixgYYQiuYYHFKj30ciqw+EjmQY2iNaWpkAQoS78DhJiYdaZqi8kl2OMHrIizTnEobJ4FDSjmGMtQ0G1Xj5kuS5FfIKaF4iVUSXgFxTQO+KgKuZKe6KC8uCBKlJ6ivQApBrnIylWHK7f/fdV1MrTCU4tn7r+L4sWN4tk3NKgJYNBxRkoKo14VKGUMkqDwlHnQIgoDAC2h3tuj323iOTRL3SJMelcBFq4RjR55gcX6ezvmLFC0niRwHzTzPEYbEcQr808j1dATJBO80DIMou/Kam6aJVHo6GSOO46kwYoK5mjuu/XfjeEYEUyEEQmoaszNoEgZ5ykNHjrE0V2L1UoeSu0iem9TqdTY21qjP1CmbAd2tLnGaI0wLO+vhGTlhlCE8B7TGUJo8CZBehCfAqdcRecIjRzdoLB2g2bzI3MI8caTpRIrMHhIYLlqnU8WF4zi4boDtWgzbXaqWII06pELTjGJcR2CZmijWDLRms9dmLUvxlSTdCkmXSsyt7GerY6FMB0mEIQSuVyiM7vry47zxhVdx1YGE/bPwxNYmhmHw5MVzvLi3j9XLF3jhrfvQKi40gFmKkibKsIm0wBHw0he+kB/4/jfyZ7/9n5B0cMoeD564QMuwsbLwims9eZ+1ACO3sDMQWYJpOjz60JC//ed7efmtM6xf2uTWG1/Mp75+Pzq1cE2bXKW4NtQrDlnYxQleylbvcYbhFoMe/M8/9BIev/fvefzEfRw6dBXlwKK84HJxax1/77UcFLPTLKPdrjLspVi1nMFoxJlj5xiOMoZZwkilJLmiZMKu3T6QEcU9HF+jky6pWyWTPZaCkLe89XZOt1p84p/PgbKoV01ed+eN3Hf/Z9DCJBIK27WxYAfcY5CmMYYhpzh7JhW2ZewwBt8RfLDRWhUjcpQCDSkgpQBMNBCrccmoQSfbnfVJ9iOANDen1VMRDAVRvB0EpJSkmUKpDCXFNJhm6Y4scaL4QWOZVoGxxhmOrKFUgtIZhlEEzMIg3UIakiRNkGMT5TQzEGOmgCYvTJ/HwyInZfNOiMLNE3q9HpVKhXavTyQlKYJUOBycaXBqoIi8Cv3hJvP9dURQIXBNUndY2OGVa9Rcj4WZWbqdDcplH5Vl1BtLDPMEP8vY6vUQeYawfIRZxs4j0jTFBLxxxqmUQhg5aZaSpHq6eWT5tuyyyMKLn9PxRmmY4BkGUTQky7fPz7IsbEd+58b1f8PxjAimSRzTbbeoN6oonWLbFpWZOr1uC9d1GfR7LC0t0et18AMH18kpl0w21gcoIeiPesSpBlmUowVloihtLVMSuB5JEiEyA9uQCAknzlzm4FXzHHniLIYlcaQLxMzOzjIcDrcVFxTjpcWYD2cYslBaqAxDS6TKUXFGHKZo20EkY2GBgiRJaDebaJXh2wZ5UsyqUVpjmwYiKVz6v/HYA3zv636M73/Dzax/8BjDYci37n+UX3jTHaSjPu31TaQsMePPYBkCjURphSENcg3ddmGv5jvgOHDixAl6vR65CP6LN3givcvQbLZbPPL4UW64/iZmZuf5Nz/9r/jEvV8mCk1yMnYvLXFg/yy+7/Kxj3+Q9TMRUdzhBbc8i7f8Tz/B3qUl3v2uX2MwkiBTsrhLu7NGqeLzxXuPYlb8aSCZPNDRuTOkKiWLM6QwkLaJgYmTSoJSzr4D13Di3EWkU2W9s8EwFBiujZUOeP7V+zm8dx9/9rt/yPGLG9i2S7c54I//6A9YbFRpt9t4ldoVmNkkGBljM2HD2FbgFNLCbyeQa62mGcwV5a++sps8/fsdJfUV+KNIrygxszy7guc4Kd2lnMgn9bfhnUJqpJgMp8hgbJ6c5iGGLAj6QuaARAi17eFp29OsV+XbOKSUzhiOyDCMglifphlab8s8M3KCRo3ZhQUuXLhALiHKEpIkQ6kahmWClCgU+w5cxTCMkFnM/n372Op0GQ77eJaNkIV/sJSSUqk0vi8plXJAuxeDzovmlZYsztXIsow4jul2uziOM37/tnHk71Sm77xWk5J/0oQql8skSUKWZVcYnOxsTj2d47vHWH0ah5SCPI0RSjE/06DkuYz6PdI0pVqtolSGkDn79q8wM1vm6mt2Mb9QJdMjsDSp1ERZSi6LwCC0LvBBBSJPscxCkYIhMW2H6kzAI0cv8sixU2jHpD5fYxQNcVyXNE2nQP5gMGA0GhEEAY7jUKlUcF0X3/dxXRfXMbClxKTA2SxpojKQpk2cpVhSMlurEtgSW6RIIXBMG0uaxGFOnsFP/vib+LN/fITL62f41z98B2rUp1Eps7ra5eyZUzQ31im7PouNWXzhYBkCKYrup1YZFkUpmiQJUQy/9Eu/yGc+8zkK/vL/9+2dOI8pAdoyyCR0k5CvfPNRtpqCxx57GCE7zFZcKpUK1ZLPpdVV/o9ffyfr6+toJVlvrdPqrHLvvUe47Xtexg/+yE/w0IlzXFjt8cTxC9x22wu5+uAyXrlErCBGXjo0awAAIABJREFUE6OJtKKfxLSGAxIBZqnMoesPEdRspJ1jWBAmEaVqiVfe+b2cvbTBxc0+W70UJVwGrRYLrsGv/txbcZOUC6cv00slm/2Qt7z1p5GmQdm3CVw5DVATitJ2wDLRupApJ0lGFCXE4xWOIkbDcLriOCaKIkajUSHKGK8kSabrir/P8u+4Ji//5DvY1nY3etu0Q0+/59QZaRwECwNya7ps28TzHHzfpVrxKZUdgpIzxQeLDr0uIIZxQInjmCxPCvs7qZFGEaB1IYFBGuC4FoYpsGwDz3fAs8ltgwtb64x0RmVhFuWYlBs1wigiShLCOGJ5ZTe5VjhSovKUTnsTz7bwbQsokotms0mpVJpupvVyiWqlRByN8Gx7DEsVlnxJElGvVymXAyzLQOt8OmI9HSc3T11Zlk3XTqOUiQrKNE1835/iq5ZVMCTCMPz2l+T/5/GMyEylENTLZbJ4yPEnL9CYKXHds6+lNxixvtamMVMjTSPanZCbbn4OKh1xz93fwAlKxJmgG45IMQCjMIadONIAvmMgVUqmUuIkJY1SqnWTWFS4+vrncdfnPsvCrgUubKX4QUASFe41rusyGo2mCqYkTcnDmCSMcAOfSqVCEkX4bhnHrpNmikEuuXjsPJlfxjVMhNQkYZ+FehVbO+RRglTFmOmya/Hsq6/h/e97H/6CR5hIdi86zJbgcquN61qUZhaQtsfyrhWGwx5JmrC4MMupc5ukKse1XTSwtnqRD3/4w1TKBYaV5wV3UUuJzrYB/J00EKmZ+j6qseeAbfucurDFmbM9Ni8/yMnTT/DG/+F7+Z0//ziOCZYNlZpDGHY5eOA60DW+cNfnOfbEp/ipn3gLSJP2oODTPu/Qbl5wy/VcXnuQT3z6AdyKR2YWyptMaRSFJDZRhev6wuIs/e4qNz3vMPc9eITyjMH/8tNvRmchqJx6bYZLXz+NF3iYKuaXfuatHHnwm/zd336EA4dfxsn7H+QVr3gFH//kJ+kPQkZhgjS8aXYzyTYnL5gU9reVd0pn0+FuOzPKJAnH/46nZEPfebPKx02qSScdrnRB2mnsMcm4dtJ6tNbTMn/nvy8649vYaNF0HQdeGY7lk4VrfdGUKUrcp7IKCjXhtgGIYQiE0OR5Ng3UV7AClLgCc+z1eoUkNAxpp4WHb1ArMRyNWNscsVRrsLQwQ5aldAYDHGObSbKyssJoNGJpaQlbelgOnLu4yvLiLMNki0xlDOKYJA1xXJM4GWE7Bu12m1qtVmC0UUS/359mqM7YlX/SoZ8E0Mn1m1zzyXWbBFfbLgYITjyJe6OnF1CfEZmpRqNUURpddWAf9Xqdc+fOTc1NXNdhFA7wfJvGTJWjR4+T55ooSuiHCUo4KIoyn0k2pgpXba0S0MV8Ji/wEYZBmmkurbUp1xq85LZbWViaH7tM5dOXrtfrTXevSUdWSkmlUikG7AlBNxrQGnYYJCO64ZAwz8koXgbDtLEMk3q1UtiYJaPpjQaI45S3vvWtlPyA9Zbk1KnLiCzj2oO7MCUMw5SgukAmDMr1GkHdZ++BZW656WYsywQ0aZoQ2HDj4cNUq1UGg6LET1Lwxh6rrluQwC3LuuJl3rmSNCXOUqI8xfYDzp7dYjQa0ulc5sDeFQLPxTDBdmA06jE/P8+5sxfZ2GrT6YApLb71rSNkuUW5voeg6vGTb/kx9u1fYqu5ydGjLTJVQehC42ZKC8uwMaWFxEAoyTe+8jWuO3iAesnDkYKoF/KCG5+NTcbiXJ1atcxMvUYcj2iUDFbmK5w6dYJQG+x7zgsQaYKhNBfOX0JJi36qaQ7SscNQfsULBmNKEHIceIq1k9j91AwHigpq53X7TpmREAKVg1YF5GQaBbfStlw8z8PzPHzfLxozQTBthkw+b2eg3WYBGNOxG7ZjYjsmhikwTIFpSWzHBDIsWxIE3vT3TL6naZp4njd9FqQsNtviVVHkeYoQGt93sW2TLEvI83S6bGngGCaOYVJyPQwNIlcgx2POG3WEYYAhiZMEdE4SFWW7ynMMoaeDKbXWeJ7H5uYm6+vrPPLQg2xtrhOHEY5loskpBd6289ski7ftaTPJdYtqqVBwbTeXdl6zSSZvWdbUWNq27cIKc/yn67rT/+77/tOOY8+MYKo1lXIZnWdcOHeWfq+D5ziFachwyIULF5ASTp06wdz8DM89fCNpkqExGA1jcmUU5A25rRiRUuLaDiU/KMbEjv1OTdMm0wovqKGlwVaziemYJHnCZrNJo9EgTYsRzhO8abK7TW7QZGeLSRkkIyKVEamMhHHJPIYK5ubmuPbQ1bSamzSqFcqlEhKBRvHa17yKX/uVXynKMGZ4xzs/gsgz/u3/9vPUqwHlks/FjS69KCPMYizfojfc4vWvew1SCBrVKrVqmSCweNY1h8iyjNe97lbuvvtubIsr8MEsy0jT9DsG0hw9Fg1qlNa0O0M+8MGPIyXU6h5fu/dL3HnnnYwiuO66fdx8y/NIkoRDh65lY7PNu975v/KO//1X0Ao2t0JOnV9ns93kVa9+BZ3uJssLi/QHEMYmo/4AoTSuZeNadmEQLA10mlMNPG6/9SVsrV2mdbnD8pwkGbYRKibqdcmikEGni9DgefDkY9/iri8/zLGzMY+dXec33/3r/PNHP0al5JEhSJSFEtY0mE6GJ25ThrYx8ckhhTldk9pGYEwH5+5szkyejcmavOyF4U0hLhCGRBiFT0SabwfnJEmI43gaBHZ+P9jG+izLIggCqtUq5XJ5GoyklMzMzBAEAeVymUqlwsxsHd93MUyJ1jm25U6hjcmk3gnsM2m+SCkJw2L+WRAEuK475oI6V5ybzPV0JcOQdBRBmuN5HrlW21x7rRmMhszM1FFZyqg/wPe9cYmuqVQq7N+/n16vx8rKCkEQkOc54WAIQmNaEp3l6CwnikYIoUnTGCH0OHNOp5uE4zjMzs4yNzc3rSJ7vV5xH6XE87xpEJ0KJHZwTCfwx+SafDdoUs+IMt80DEoVFzeo47pL7N93iK999VvIvE0cplRKNRr1Bvuv2sOly+v0By2yTCGFg2tJOr0+BhY6k0ipsR2TLAxJpcJUObl0STObeNTEdjxqwueRr3+K/vcd5rqFFcyD8OG4jeMucunSJYbhCCsa4bgu65trhf2aijAMi0hIKo06SaYJKBV4bmKQRRmtbgfL9KjaAfO+yV/99V+yZ+l11BZnuHwpY6Wc8piOufrQHr7+xc/T7OXk0ud1tx/mxIPnObXV5/mHK7z6hRXu+WqHaHOT5+xpIHsXWL0UEQfL4Gu0m9ONejiWi8hS7n/oYY5/6+s8+6aX89FP30NmlRgNUwyZoSjkj8IojCAmZtWT0t5A4O8wgRgoxXo/QdtVrrn+al546wqnt6rcfPMuvu/1r+P9f/k3XDx7hiQKOfXVT/Br/+bvefc7/wBZqWHWFCUL3vG2XyARHTpJzIc+cYYwM0mcFpaUtAc98lyNzYWLsssyHfJOzB++5318/d4v8aLn38S//9138/CTD/HBv/87XvPq1/Lef7ibjoJGHf78t3+D1pnj7H9Jzr0fuocXqQ5vffs7Cmu6OOS3f+f3ePd//A2GwyHR0NhRchfKKaUUUmzDH5NDm4UJR8EukdsUGuWQG5qEDG1o8jDFszxyLFSiMIVJkkYYVgKGwsjL4zHDEp1N4AWBtgoTccsugkuWZYhcUy6Xp6Xq5P6Ydr5jEy8oWLZpgJ6l0+mwfnEN3/epVquFb4VZwAKu62NbGq1zclUwFiaBCMaG6rj0u0OyLMG2LRzXAq1QKsU0JXkWFx6nAFqiDMiyoouutcbynOn17GNDFiHHNK9+6qEsiFHUZ+dJlGA0zFFGwrkLZ2nMVml3R8xHEXE+Yvfe53D5wvnxvYi5nLfITRMjN1C5hWl4CKEpl6vT6nUS9CdVpGVZLC4uTptVaZpi2zblyqQiEyhd8OMsy9qBSecw9VH47ySYCglpNkQampuff5jPffZuNBmmY6GjGGEUeFar08R0LNrtfsHZk2pchuXAtpohSRJ8xyGPYiIhMEyTbjjEsg1inaMtgzzWCKXp99rMNEr4gU17FME4i52Mf+2PhmitsfFIRjG90Rolp7Dmy3WfxaUFALa6bdbWugwihWtJhv2UP/39f4crz7C1uYnn+tz28tu55fVXUWss8Du/+i6uP7DAa3/0p/jT978HncLDjz7O4rzg59/6epZqX+PafQFPtCOqZZc4F/QyzZ6VWQJXUq42iMKcrN0nSRUnz12ksrxeMAZFYRKRZSmWvX2LJ9SXf+nwvBKeToiGCflwyOJKxv6XHebkyYBouMarv/cl/D+/eQ8qy3nxy17Ef/ytPwQHBlFEUK+Shl3uvP2VtNsbJEpy7vI6Q5VhCqMY3y3N6cytSUmdK4sYxclLfd7wwz/AxSbUXcmR5iorDZfX3v4y/uCPP8ms66J6EWeOHOHP/+i9/Nvf+7/YMsq8/68+hiFgedcCnU6Hn3/b21FAtVq+Qj1kWdb0PKUwpuqcybEzY51kgXmeYwhBluYoYaJTiZELPNMhzLpYhoflGphmGVNmGKbCkO4023Qch+FwSL8/YK6xm7W1EWmc4HketUoVnWb0+h3c1C0yKdtHo6cNlp1qKMMoDGtqtQpBUMidNzfXsaxiEqnv1QuRiWEjhIFWFlpk04x8cr6jQW+cvTm4no1S+XhNGmRXPiM7K5sJ1lhk0ZNqbZzDj4UzYQKOG3Dm3AWUNki0RTgaUmq4PPDV+6iWAo48/BhoTapdbNMgjmNy6VCtVugmTCGZIovMx989xzKdK6qsyXOUJIXtje+7mGaJMAxptwbjJpOD75fI0sI8WhoTHFXB1NLv6QfTZ0SZL4TAsosd9PHHH6XTaWFaEtO2uOZZhxhGQ0bRkJn5OdrdFmurm1SrddIkn04i3XlMStxGo4FfCihVKwTlEqVqhfmlRTKhcd2AwPfJ0pAsHTHoddFZfkXJM9nhhBBILXFMi7Lv4domeRrhBzadzhYbG5exrALE37W0zK0vfxHDYci73/2bBL7L7pVlRv0BH/jwJ3jPe97D29/+Ln7/d/8DJU9i5CGD7gCVQrtpUC8v0yiVWJp1eOC+LzAcNGltbWBKA5GmVH2TlcVZKr6DZzskKSwv72H3/qu560tfwfJKhcWbUlhjZ5xJQJmUNE+9XjuPMI6JMvjkpx7BwGC27NFrXaLswXXXX00Ydnn+zYcJox6/+Mu/zpe+ej9OqYywi8bEsB3xtp/9Gf7xHz7AE0dPcrnZwfP84oHP88LkWAgyrVFCgGGQa0mKienCIIp51zt+hOb6KsNOk9laBUso9iw7zNbLHD7ks395N44L9z/8GMdOn6WxUMf3TVqtFu985ztxHZNarXJFh/ypZVyWJ6RZjDSYLsuypqXtJMg6joPvWviOS7VUZaE2y96VZVQ8oGxp5hoBtbqP4xVEcp2DptDgGyYMhl36gz6NmSr9Xpubb7oRKTSGkJjSwHVt6vUqSRIxHPbJsmSMaRabYBzH02AWRRFplhDFIUrnGKakWquQ5Smbm006nR625SKlhWlamIZzRdDRuhgHZNuFCMT1Cv5swZbZZg889fmYBPZJ2bzTLOSpUJgQgs1Wh1avz8ruXfi+T5rF1EtVTGmyMLtAHCaUgwq1cg3Pd/E8h1qtgj3e+IvvtEN1NQ6sE5hkJwY++TuERqMKmANFqRxQqzVQShJFCa1mD6U0AnOKg082qu+WGuoZEUyllAwHEVGUYFkOs7PzmIZNpRbQHfRYXF7EDhyiZMgwHDAcJCSxHpf65thncRsT2gk+V0plsjghjRNG/QHNjU0qXkAegiUly0szKDVk364F5mYbeJ5HqVQaz2UqcC3HcbBcSanm4wYuSZ6OXW2Kh8nzPITMuPW2W0iyNmdOPsGu5YAXv/A6bLOgdVcrJeZmGwyHObWq5L1/8R7e8uYf5iMfeC/ff+crqfuLvO+99/D5zz7KsaPniYYt1lfPY7g2m50eQbnEytIcedTm8HX7yZMhrmMReBKEyfL+qzm7GjGMUxzXL1Qi4+symX+zkyby1EAzWZ7joGSZ1Q5885HTPHnyLPmoxXMPX8dDX72bYbfJbK3KrS95KX/+3g9wdjVjcxAjTJc4itg7U+LqvXu57/4HSbHpjIrutukaCGmDsEBYSKPwOtCYKDISYTDIBacvb/LwI49x6tQpTp8+TRzHHD9+nOZmQYd51ffexqc/+ykiDDZ7CQ89epRBd8jc3Bw/93M/x5/8yZ8AEIbhlO6yU4c9wcpsu5jaYFkGjmMRBEVjqFwuX6Fnn9DiPMfHQODKDJm2+dVf/km+786XMeht4vlm4awkDBzpANvd++EwJAiKRkfJM6iWHHzbwtCKaBCSZhGWLZmZreH5Nmvrq7Q7W4RheAUWO8lMfd/FHwegyXdvNGrMz8+SJBGDYY88TwBNrhLyvOAya100gZRSlMpuQXmiMBRyXGN8Pewr8MUJpgpME4xJ8/WpbkwTLq+UEm15YLpsNdtkKsd3PXJRwHHrm1vMLSyS5QJp2tRqpTF7oAjotXqp2OSkZGNjg83NTYY7rPEm7/g2/csaB/iMIrssVpYlJEnE/HyDRqNGtRYwGg3pDzrTqcE7P+/bdPr/LXHsaX/Cd+HQWpDEgLY4fuwM3c4I0wjYam8xioYMwgFbrS1m52fpj/qsrbZI0xyltgdm7TySJCGKIrIsY7jVRqQ5rjRxMfAMC5kpLMOh1+2yvnaR0aBN4Dv02p0pmN1qtRBCMDs7y8LCAsGMiVez6YwGhJnC9Ko4Vg2BW+BwOmHPvjrX3bDM2tpF9u9fZGVpDtcx2dxcJ40Tdu/dx/d8z4u4/XteTjmw+dynP8Jb3vwjbJ67h1F3DdOxeezYE+y+eo7DL9iNwsLyGlx9w42Ynk+qI3qddf7Vj/wgWTQgi2OkNLnny9/g1NlL1Gc8hDTHnMKUNM6v6EZPXoB/6RBkZLgkBnzwsw+TuDMsVGucfewxXGHQWt8iCjOOHz/N/Q8eQdiCUZrT6vaolSvcfPgwZcdj794DHD99FtN3ydDEaYRCkilIMkWaa9Jck2SKRA8IVUaSCwax5vTJyzS7fdxyndmlFY6cPIN0YZjkOBWbxq55tvo5jz52FJWBihJ+4zd+g3/6p3+altY7O+Y7f56sJIkKHb45Ie6rKR8TmNJmtv1ICz7x2voar3v1C7j+2WWSwRYHDyzRH7SI8iLYqzgnSzWddp9Ws8vc7DyloIrApFLyeP7zboQ8J41ihNIEgYdhFGR0z3NYWprDtk2GwyHt9rat5ERCuTNgTL6777uUyg5z8xXm5muEUZfLq2cRMp3q0judDqVSibm5OaCgQQmhUWPZqlL5FAZSShGGIa1WC8MwphvM5PrspBztzOqUUgyHQ05fuMwwikmVpt/vs7W1QXs4RDoudqXMmcuX6IYha61WcY4qxfVswnA4DaxKFVNLy+UyWmuazeYV77phGFeQ77MsGcN929fHDywsG6SRk6uI2bkS1ZqHbdu0Wi3CMJwydIrr8vSOZ0QwjZKIVquNa5TZvNjCd8u0e21E7DIzU8erSO688xUsz+9m42SXsmmh85hcp6g8x6NEMjb2TbUgjHNsS+JYCR2dk1smmcqxfYfMSEk9RRgbqFywMLvATLmKo0y8zCqci7IMw6mwsudqkjDjzNHjhOc6tE9tMufO4aQe3fUR/XarIMdbJbzyIl+55wGyQcqNh66hF0UMpaK3vsFKvQGuySAfMV9NKHtDGvv2Uls+wEPfepTf+rXf4UUvKfHDP34L4Sjh1Ilz3HTTARaW9nJ5o04nbNBONRe2LqDdAMMR7D04i+V1qS1YDBlhVWuMdEZQ9yiVXXzHxzNdSDI808bU4yaMgByNg4UtLAzDAtNCWxa5ZWHpjIq+QKrg5GXo9n0eOXUCr1am0+uRxoqtzZRRNstHv/RVRkrjmg5lwyYZDHn1q+9gdncJy6hiZFXiMCJRGaEOGGUZkVIkMP1ZWxa2WUIoietVUMpkZmkfotNjT2Dzqpe9hIdPXaSbwDX1hLnI5IF7vsaP/ejreOy+oxxYmOOP//pPedOP/wTtVpfV9S1SDVGuSGURfJTKxrgb0wDq+yWSJCOOU7KssKOzZE4eR1jYWDiY2iAZ9clExjDrM8pGKOALn7+XrQsRX3n4MhdWh6i82KQBetGIrVaPfqoIVvaA6+N5Aa6QBDrmj37/D0m1JjMMlMgw8hxLa2yg7DiUHYf5Wo3lXXup1mdptnu0uwOiJMewXHzLwDMMPMPBkz4uVUTso3OJZbhIBAvzcywvzZOlhV2fabisLO+lUqkQxV1cU+AYYEuBTjJKToDIBDkOYSLojRJSDeV6A+lYZNmALB2BTjDkWPChNJgp0hMkIqMXhkQ5lKpzeFrS3Wgz7A2xTJdqbRalCiVhe7OJTjIafpmkOyBSNtoKSDKo+QEV26LhmZiGQRonWIZJuVRifnaONE7otLeKoX+2hel6WH6ZxX0HWV6ZI8tDqjWfas0nKNnYSKLegJLrEXg+vV6Pcq1KnhdMBMOw6HZGbG50ePKJU087jj0jgqkUhZFtnues7N6NBpIspVTziVXCVdcc4MjxI2w1myih6IUhicpJVU6GvsJIFqBUKpFlWcElsx1s08RzbHYvrzBTq+M5DguLcyiVYTgW0hRYlsSwtnW6E9jAsix8v7BjE4YkzTOCso+U22VzGIb0+/2pb2J/MOLcpcvUZ2bxgirSLBz/4zBkaWmJQ4cOcfLkSdY2N2i1Wvz6v/8/+b3f+wMGgyGLi8ucOXsRrSUbG2vs3bsbpTLa7TaWWQDppuPywhe+mDvuuANhgOM7hXcqRVa+sbHBYDDAMAwajQaDcDTNOiZZ6ndSimitybVBBli2ixbw+JETeI5LFI04ePVVzMzMMDM/x/lzF8lyyHKDNBeM4oicnOXdiywvzFMqlTh39jx64n7+FJhWa11Y4SUJo+EAnaYoXQypnqmXibOUZrdHqhUX19YJai4/+7afZ3F5AS0Uv/CLv4hjwMEDh3jzm38GJUGYBo7rksQxOs8RWYGzbUs0t4eoWZY1/f0TK7udcMBEfur7PoN+SBpn5Llm/54FBv2Q+7/18NQQZ2JkMnkegqDM3Nw8lhS4tiQc9XFdkxe/+MXs2bNratQ8oSzt1MJPjsmzND8/TxiGbGxsMBqNiKOEPN/GQDUphZfEtkvVJKtbWFjYbvLtOPed6qogCBiNRtPziON4Gmwm2fBODu1OdVae5+hcFeaZWUYUhgwGA1rtNkEQ4HlegT+r4lzyPMd2i8/t9nvMzc0VTd5+nzAMp3ju5LmUUuK67lR9eODAARqNBqZpsrGxQb/fZzgcsrW+RhjGBEGZwWDEcBgWzaoxh3SC+VarVcIwxPf9abUy+Q6VSuXpx7Gn/QnfhcM0LfZddZBWr4O0TTpRn/m9i5RWKoiywVpvndrSLI8cfYSzl88zUpphrullKbFQpKZAoJBaIdCkUUijViEaDWi4HmIUo4cjWpdXEXHMTFBCZUMqVQ/MFG0k+DWHoL4tGTUMYxqQpJRo18IpB6Q6I1Yxlmvg2VbxO3WOH7jccPh6DNckmJlnbnkPq1sdsDyGiWajPWC2McOTjz/OaDjkmmddy+W1VeaWFth14AAf+/Rn6IUZ2qhw8uwGo8TljT/8ej74gb/hxPHjpGHCxuUmju2ztdViZfcuLq5f4rVveC1O1SYIPIajdKpgMc1irK5Silq5MjWymLxU2iw8BqSURZahNFJpEi1JtIU2fDLp8bm7vsFV+3bT3NqkubFJb9DngQcf5v4HHyTKy8S6TKIsnMBF2BrTSWg1m6xeXueebx4p5glpiaEVUjNdZEWpO1tvAFAuB+TxAJGlXHtghfV+B6PkM8w0R04PaA4ijp07i11y6SUjfv3d/zelisODDx9B4DACUqExbIt6pYoMU0S47fY7wQ13kvKFEARBgGVZU4x1ZyMlSQqDDylcyl6dql/BNj1q1QVuesHtUyxz0rDq9YoAMT8zz3OedQiHEXnUYu/uKrfe+jw+/JFPstVskWuBFoUPrjDM6dJCTpclBULl2IZk764VVhYX6LVbrK72iWNBkipyUnJCctH/tvJ7UpJPmiwTU2nDKPwcFIJcU0xhMC16gyGd5hZC5VQCH1OAShN0ll4hZwWm0IFteoUMdxRiCJipValXA2bm5+gO+vSGA3rDQcGxzRXdwRAhi8kPea5otrucP3eOQbfHqD8gHI1YW13FlAVumyTJdGJpGIZEUYTv2jTqNWrlEuicfq/D5sYao4HCMsp4Th2JTxobU2y0Xq9jmua0mRdFI/bu3c3sbIM777yDd73rHezbt+dpx7FnRDDNlWIYZ0jbYZTHzO5d5EJ7lZFIKM9XWd63h8eeeBJhOAwHCVg+gyQlFwLhWEQ6wdBZwR3UCteWGOTFHBuVgUoQeY5rgG+atNdX2WpukqsEnSaU6hUScpqjgqO2k7Dc6XRwHAclDVKVEpQc4mjAXL1E4NjM1ms4lsktt9xMrBIacw2yXJDmgs1mF9N2SJWg2e5RC8roXHH+/HkuXrzIzNwcl9bXqMzNceLCJfz6EsfObPIDP/rTRHmVmfk6QoDIckw0ntBkYYdd8w32LM9z+eJFLl26hOP6PO+m57C4WCkI27aJ6xXa7UnAmJDXJxZkqVbEeUaUJEhApxmGBtO2yXJBhgmZ5NiJy9xz1+e54dprSZOIZrOJX66gpU2OQ5YVrIvBcECjZrJrVwmZZXzmc1+iXi+TCQehZXF/ENMutkCA0gx6fZbmFxkOeohcIzIw8zbV2QaOX0EZAd0RlKqz3PbKV7B88Gpefser+dQXvohXrtNsD/C9CtXZKkiB63uI8ehtkWsGg8H0vCdcTrhSXVQqlSiXy1NtPTDlfAohCMo1fNdjvl5htlrnjT/0P/L+f/pnFhYWuPFAEMcUAAAgAElEQVTGG7l8uUkURTQaDbIso1ZyWKi6LJclKw0Hi4SPf+yjKA1rzRHCtNBIwkRx/uJlpGkTJRlxmqOFQZIptMrHIz3AMg0C32Nudoa5xSXWNrdodtqMoghpCZQsNsinZpGTez3ZQKfKINMmyRTCsLAcj05vQBineK5D4HswTkoEGkNuq7MmZPgkSQjDkEFvhE40s405dq8s0aiXCVyL+kyD5d27QAgKf6vCr0IaJrkuJhPEuQJh4shiSKHQFIMqpcFMdXsS8UTYMMlgHcskj0cYUrC8MM81hw5SrZRoNrvFGO1hTJIoTNOdavihYEVMDE0MU3L23BmGowGPP/EYf/nev2Bt/V8eoPxfczwjgmmWZaxvbGI4Nl61zNawycLeRbq9Iabhc/SJ0yzN7KZiNSCysPExcnM8TFwgtMKxLXQaIcmQuph0qvKMJIvRQqHIsV0Ly3cYhAUVqdcNEYbNMEq46cUvYZTqKzrAYVhostvtNq5hIdKc4VYTEYb01i/jmiZxOCJPEx546AHOXTzPwWcd4uK5k7z0RTdzzYE9qCRk1G0yUwvYWlvn8PU30Gm1UQIWVpa44zWv4r6HH2K11eWBx45z/FyTd/3a79INHUbDnKuvPoQhFc++4Rpufu4hPNWhYoaknS366xs8ct/jnH7yEnNzMyRpSLfXQRoawxRo0iskipOMJQxjlATGzvCSYqSvhURnEZbUGLmiUq2ThXDtoat4/JEHsAyDaw49C9Ny2Wr3UfkQ28ggHTIbwFe/8EmqRo4tBWEICoccGxCFH6aUaKVIkwTbshBAlqZsbKyxZ3mBO267kcPPCvBkiEoznnvDjRx97AS75msMuhF333UXa52c+x45iVueRQtBpjNSHZENQuJhiGUUIgXp2fiNKgsLC1OnoCiKpqX8JNOaNDJ2ZjA7fUQLpoai1bzI2RPHePZ1V/HFL32eI2fOcPr06WmnuVwuTzO3Vus0Sf8C3bU1XvXyF9Nb32Lf8l5e9LKX0pipECYpuQZhGJiWzYmTp8jywq+0UEFrJGq6dJ6SxiGeY2E5sLJ7kUqtQm8w5NLlTdJ020F+J+1nQmOaGKdPJbDSQBomSZqx1WyR5YrGzCwz9SqWIXBtE8cypmsnDBHHxYCUMAxxDI9apY7UMOz16HU7RKM+R48fI0xitBRoQ5KqnN5ohLBchmFElOYIaZMh8MfyVJ1mhRlRmuNa9hSymGx+GxsbBEGAicKQ4NsGWuV0tjbwbItKpUStVqHX69DrdWi1tqb0sonr1OT8Xdcmz1OazU2OHTtCFI247bZbn3Yce0YEUyEk8/OLzM7OM4hHGJZFe9Bh9dIGqxfXaG+0sbTP1moXT5aIwxhTmohMIZXGZNv4QQgBejz3xZQYro3te8wtziEsE8OSLKwsMz+3QnOrw6AXkeUGDzz0GG6pOtXiT/C0CfXClgY6yagFAb5pUnM9VJaSRCGOY+F5DtffcB133/1FjDzFMeDoE49iCk046OBZkpIf8PBDD7F//36CIGCz2eSTn/oUuZA8fvQYSJtMGfjlWb5x/6Osr3epVWfxHIsnH76PzY2zhK3LbF06i5mH1IMyvY0eZ45coFwpcfvttxME3tS8YqKy2YmTQqHLznWhipoEE5UXmWPZt7n6qt0c2LuHZDggcGDQ7WJZBvVGldXVVVzPI87AtXNMI8aWCdfs38XC/Cy+JRkNhgwTCJMUPRZTSF14JQilkZodYk3Bna+8k1e+8nYatTKvedUdVEo2YW9AOajw2MNPMFufw7Vcjh85zrGTq2y1Q1JlEMYRhgnSyLAU/OgbfwhTFPDFMI0ZpoXbU7VanWadk0xnZ1k8eXGTJCnI72Pji+LZFGR5xOxcnT2763zp7s/yrOsOsd7qsXfvXu7+0tc4cGDXlMsrhKDWsNjYOMO/e/ub+MSHP4pre/zC29/BsWPHCMpl9HjOlNaapV27cYMS5y+t0ekPwDAxHReh1XShcgxRuINlhJiuAAPmFhYRhsvaendaQe3U+8N2hr0TMxWmRZikDMKo8I2t1ojSjGg0HE8l1Vf8/p3m1ZNsr1arYZsOKlUMB4MiYMcRaRbjl0psbGyQjBVTWoA5njIQJcVnxVk6ZQhorQvWhetdwTaZuEDZtk29Xmc0GjEcFiKaKIqIwyGNRgOBplT2KJU96o0KS8vzGCa0Wm3iOCZJkummkiQJg0GPIPBYXJxn797d9Hodnnjisacdx54RwVQKzfxiiX68ydxCA51J4rYgmGvQGfSJRzGbm1sMo4RukpHpCClNTOkhMrCBTLtoZeFok7K02Te3i5LVYNhsQZjQutxERJr+5oit802anU1w51HOHoLy1Zx8/CgNM8acn8Oq+Ti+QZyFYFnktkd3GDHUMDQkfV10itdabUYqJTYVtZU57rrrK3TWItY2hmydP0fJCRjYMwS7D1GtK3r9FgvzSySxptOJ8IIKK/t2kaeKmWCepbkGppeSmDZ//YGvc+ksLO6u8JnPfYF4YPPNr3yBeR0xK0dcu7fG61/7MhpzdeaX9vInf/U+fvZtP89cLUCqnFQ4dCgTJ4PxELeiIYCWoE1yjCLvUQoDzVytSqMaYGiLk6urbFy+BOmQXIFf28PsygHW2h16ecxL77yDzDIYGlVyO4As496v3cXGpUt84+FT/MMnHiUDfK+MoRKUTom0AlFYKUpDYVpgmEUD5a4v38eH/v5eHvrmI1TKBpsbZ6mUIi6utnjw4Qs878Ac1XSLrdWUzWjE8r69uKbFVUu7SMIUoXKuOniQ97//b7lw/iIij3FI8c1sSuyeYKNCCDqdzjQDdRxn6tyUpRUGiYPyS8SkuCWDmiNwVRMRb1LyHF5x+6v50D9+lOccOsRjFy4wuzTLsNNjseJTthJ0ssUPvOIWXvWKV/Hg4y1OXpJc3rL5iZ/6ZRJZxbNLWLnCR2DkmngwYnFmjmsP7seWcO7UCQbdDZRwsdwqSW6SaRsMn1RZyNxCJ+AaDpYQLM/PsmtpFiUlR0+epjcaoQ2DXAgSpbBMibQdhmkGhkc0ymg2N+l0WgihmZubGXuESrAV2tTEKiGXkCHIhYlh1QkTg94wY5SkeBWfTGS4doRpJliWJFcaTBcMH50V/gu+aWKkCRVTEkcDkjRHCQNl+JAJzCzDSRNElGJbHrbronSCoQeoRCGlT5iZCLOEilNkEpEhKVcKr9M8TdhcvQhZzHDQodVcR6uENBlRrfjMLCwwiGI2tto0t3okocA3K5SDRbqdhE57yLlzFzBNk7X1S/+FKPVfEcee9id8l45i3lKf06dPkyQJu3btouz51Gs1wjDk4sWLtNvtQto55gBe4dQzddopXHLW11cLt5mSzzCNSSUkKLLxn5XZeUZKsDVMudTsUZtbptXtkw17WCqnt7nKQq2CTcZ8tTIWNQuiJC6mfAoKX0Tfo1yr8uSTR3nhi17G2nqTJIcs18zPLRRMgCwjT1KuufYgP/CDb+ArX7uX85cucGntEqZpcvDgIRzHYzgMSZJi/o1WgkPX7OVFt9zAJz5+L3M1h+fecC2jLCHOUyrVKi952Us5fqpFq9/m85/+FBY5/dYWpk4xVQJ5MpUzhmE4nYdTTMvc5hQ6jjM1zNi3fxe5iugMmhy+7noOP3cfw16LxeVlrjmwH0fmfOqjH2ahUcGzoeYJfupNb2D15FFWL57ji5+7i1PnLxejtUcDtJhwgK981HbieGkWkmYDLq92Wdk1S6ZzMBw+/snPcOvtL+fWl99GlMBrXvdqThw9QpLEhOGQ4aiPbUAYJjz08JPkChYW5hDCREoLpbZxw4nzkOu6lEol2u32FJObuILVAqi4KTJr4doZz3/OPn7qX7+Bd/7S27jm0AFc36M+0yBKi052PfDJwwGWUMSjPi94/s28+U0/zt998PP840c+y4c+8Wmskg+2ZHHPwlgHnmGYBe9RiML+bZI5+b7P/v176ff7nD17lo2NjelojUkzZacxx4SQb5om1WqFlZVFWq0mm5sbNJtbTJK8iWgjDENGoxFhOKJWq1KplAFNIUSThcGLKCz8VA5CFBltkRH2kUYh0bWswrVqct12OpJNeLlZprAsB3M8EXfY324A5lqR5BlxnqFEMdW02WnT6/fH/gIujl04SAGsrq7il4rNsFwuMxqNptctCAKUUiwtLeH7/jQOTKqNWq3Brl0rBXd31KfX69LuNLFtc8rgGA6HGMbTV9Y/I4KpUppcKyynmHIYD0Y89uDDrF+4xNalVfbt2kO9Xqfd6yGMYmDeKArRY9d7YciCSzg2tw1KHkJCnIR0oiGpKXCqJUbkdOIReDYnLq1x1XNuYenq55K7DSozKwSlBnVDIvpdqgKyVpMbD1xF3m4SpQmmY+N4HplSjKIQaRgMRxEIC9st8+V7v0Gvn7H/wF78Uo2NZodzp88x7PWxhCBOR/zW7/8mh2+8Adt16HT7OL7HkaMnMAyPVrvP/d86w8Zmi//c3rkHS1Ld9/1z+t3znrnPfbAvtCyLV8AiGSPh2LIsRTKJQHYgliCWZVullJQ4cpyKjZKq2KjKdohcsYXjWMIyMk7Z6GUEEiggghCwEBaxPPYBu8uye/fu3fueO+9HP0/+6O7Zu7As4L3L3LjmW9U1Z3p65nyn+/Svz+P3+/7mF5aQqovbXeSer/8+lbljDOdt9GKWNVs2Um01WLdunHe9ay12zmBNbpi5oxPcdusXSOseitdEdaKV0OSGSxpaNKwP0IQSzSUpgpbTYWp2hoOH9oGQrB0vcWLqFfbtn+C9V13Fc088xoPf/x4ZU2XbhnHWlbKsy+mYQY0v/dkfsjh/nHa7iR8KzFSKUEDbaUYGRCoo4emNdbkcntB9ZLjEL9+wk7ERm0qtip4ZYe9LSzz48C4efnQX/+E//mseeuhB0imLd2zaSMrQmZ6aIm0bfOH3Pk8xP0TazhL4Ko26E8Wlh3rcvsJefcmiUz6fp91u02w2e8YmcGf4yAcv51Mfez+//esf5sNXbcVbPMa+H+/h/z75Cu/YupX/eftX0G01uqHVAOF3effOHfzsP/lpHnn4Ie6446+pB0Mcme4wWwsorluDpwf4uoPnt/D8Npouo0ylwqVSqfRUmpKFwo0bN7Ju/RqC0GN6Zoog9NANFT9wTzOmScdCCIGpq+iqYP3acdK2ied0mJ6a6h2XREAFQcDocIl8Ng2hj5CRRJ6uRgn+FEVHERqaZiAlNOptQt8lk7LI2BaaIpCBhyJPqS8l5zapxwlCypUGoQSh6AhVx7Z1Lr5oG6NrxvECn0ypAKZGqCl4QiKTzK66jtt1yKY0FOGjqaDqCoeOHCFUVGqNJq4fkC+WkEKh0WojhcL83CKFfIkwIBJnCQCiYX2tVkM3VCxbQSgeqippNGp0uu0444KGbWXP2Y6tCmOaSqdYWCozPj7O5s2bSVk2pqpRzOSolJcgCPFdD0URNJvNKKd2EsoWy8glArfdbqcXahcEHmgqo+vWkC0VyORzDI+OECoCxbJQrAyhmcLKDTM5NYOuRBP2iXKP5znYto2iClKZNJqu44cBI2Oj6JaJaphIRSFfLFEaGgNhMDQ8TnmpxlKlTrvVJZPJoCkquqrR6kYRF6EQKKpBaWiUvfsO4vpQrkYO5xddvJ7JqTmsVI5as4Vtmzz5xGO0GnVU3aAThhx++RXSdoqTE8f4wz/4AouLs7TqDnf85R2kbZ2RYp6hQpZMKo0Qoqds3svhrkXzzXFoD67voegaTujTbAXkclEmgYu3b2PDhhQ/3rOHVtfBsixGSkWmThynlMugBB0+cdP1TBx8lkOHX+SRRx/jwEvHaTkOTuiDBqFIFj60nmZC4kOYGDbTsrBMuOKyiwh9B0U1CJQUo+uGaDkB/+dHj/G1v7mT5/ftR1cE09NTVCpLXLJ9G52Wyy23/BGVWqXnHxkJX5zKrw70rmnSG5dSkkql0DStp6BvGPDcM4+z8+KNXPaOMdYVbSwt4KlHn+DffuqjfOPbP8DOZTBti3q9jirg5pt/h263y6OPP4Zi2Oh2inoXXAw2XbiZRquBqgu8wIlFXaL8Ysu9CZLInoSz67rYtsXQUAkpQ+bm5iiXF1FiwWjbtns9wp6wdOijqZGLoGlobN60AV2LjG5icIMgiNqCAoEfOeArQqIqRFlWY01XKQWu69FstKPzZJmkbJMoYY7sfW95bzTpNUdaGYKOD4EU+DIERUXEfsVDQ0M4vsfYurWgqYSKQLNMVENHt0xSpoXvuJSKGVQk3W47WuyyLGYWKlTrTVw/pN5sI4WKbtpRVJ0bJaf0vChly6vTzzhOl/HxMRAeuXwW3TilUzw3V2V0dPyc7diqMKZdx6HeblFtRP5mF27cxAd+9ufYtvlCLtv+E4yOjPRW81LZTE9/M1CiBHES4nhesGyDUqmAqkWrdpZpUlksUy9X6DRb+K5HLpMhbemkc1ncUCEUGvl0CtFtUXc9ao5HzfWwCkUOT56g7gRU63VCJGNrxiMneE2j3mxgWim6rke11uT45AL1RoCdGcKTGj955XsIfUkmncZUFSQampnj+ecPE4QWUydrHDtaptnqoqgWlp2lNDTGBRs2IdHZf3yR4TUbOXhwgssuv4qWY2BYNinL5jt33YVTrtBdWOCC0SGkzPLkUy9QKA1z/cd/mWarDbGeZ7ItFx22dQNT0dAUBcO2qLWaNLtdRoYKBAFUK00OvvQyrhOy8aIdvOOSy1m/eRvHTkxz9NhxDh4+xCXbtnDL7/0nRseH8VTBQtNj35EFpGkRahCKAISPrmnYRqZnyJerNwHUmx18L+TSHVuZOTmFZpSouxrzVYfc8Fo0y0YoCmPjBWrVJUZLRZyWy69/8hP88a2/z0c/8gEgxDRVGo0KxWIWx2lRq0W5sZYP9V8tHqyqKoVCgVwuR6MD/+rGm6jMTyO6DZ54+CEqswvc8M8+wle+eg9OCFrK4tJ37eTSSy+l44XcfsedHDo6ScNVaEuDqUobJ3RZv3E9rU4zctcTEk0EaKqFIqwoB4RUkfKULmrC5xQ/CEOfsbERNm26ACEk09NTNBqNng7n8sALEQa9zVAVnHaLC9auoVQq9bwYEtFoRYZn3FzHR1VMPM+nUW/h+yG5XAnL0BBh5FkgZFQHYXCaMU08CcIwpN7ukE4Z+BIkGi3HRVPUnjF3PQ8rk6LhdPAVwNBQzEhkJpfLRa5QhiAMuwjpgSL5xX95Pe/74PvYuGkz84tVJk9M4fkB7U4X07JptztEKaol3a6Dqmr4sXCRqqpkshZTJ4+SzVk4TgvDUMjlMjTqTcZGR3h2zwvnbMdWhQRfGPdWAIrFInNzcywt1rj8nRfRrJajyexUilbTx0rlqdfKaIZFvDCIjAX2/cAjn8nw8pHDjOZSaLrKSCbH3PQMZt5CeNHTVzoeiuJj2QboBpZhkjUNQttgybQIvQApBYGRRtF1TDT0yhJtp4vtmASui99uMzI6ymxtCcO02XdgN/nCEIGjY6cy7Nv/Elb3GJ++8QN0W20UBJ6vITCp1V2qs1MYuo3rOGSzWSrVOhs3bGFmZi7KrqioPHvoBL9y44dYv/Fi/uDWP2P7jgu44l2bMYXNz111NUIrMd/yGR8qMD/Tou0K1m7cwvCxSXxFx/GTVd1ok1IiFIGiqChh4jIVUG/VsSyDbD5LtxPg4qEFBrqicuVPXo2WHeb40UPYqRzDa0yyQ9OkcgVu+x9/jmLo7N/zErueeRbHz9IMTBTNhLBDqIaIEAIvJCDEE94ZtQHsTBHDWaRerlCr1Gk3JbsP7KPhhHRdl1zGYPuOi7CUHIahoBsq1133Ib72V1/lxSNHEbaNpsLYeInDLx9nZDhHLh+ptbfakUZDJpMBTnl8JKv1tm33IpkqTXh+34s8+YPH+d3PXMNDD8xw22038cVbv8zNn/sVXm7UufOb91Kv7cHwNIyCxVKjQ7vrEaDSdj3S+VFyGfDcOqYOuohvMqkQEk1jqYod6TkE0Gw2I6FmVekZeYkEEaLpUfZUVRWsXTceRULNLbG4WKFYzFEsFk8pgfnuaedU1zSEoNcr1XUdEn3UnpxzBBGlVUQIlVarRbsVRROZZpStwXejnFFR1F8kJ05vfjTSavX9AM+LDGw+V8QSLt2ui6Yp+F6klzA1NYW6uIAb+Dy79wXS2TTtZpNsPoeuaqQMk1a1TiGfR7N1CAOEiPRLv3fffQgkv/TR63GDyHjPzMzgOy6OXyOXLeB0PdKpLNVqNXKJ87pxcIZkaWmR0dERavUyQjEQIkrJHkVLhuTzRZrd2XOyY2+qZyqEKAghvi2EOCiEeEkI8R4hREkI8ZAQ4uX4tRgfK4QQtwkhjggh9gohrnjD35eClF6iU1OplF1sK8vM7CzPHHiRhcUGlZk2tZkmplDpNJaw7DSeKyGQaFJDCxUy6WHSqUysYRmFySnCpLZQxxYqOTVEeC1Ct03b9cgIi+rUNEtTJzh6aB+6BYWxHOuyBdakMyidFgUT8obEkh0MEZLXDdYXxyhlSqTzQ9QqTd753vfz9OEZ3E4KraugZRXU/BCKMcLsdI2RIY3skESYJoqhUW7UsDI223ZcTMttodkabdehXm1w9OBhNqxdT6PRYHz9Op7a9RT7dv2YHTt/irt/dJxKMEq349F1GmQLAYo2h6YsMZbSkFpArpBhYmKCCzdvRhM+atgGJRpqSVXBl9Hkvy9DQuEhidyB0lYaQ7UQvkKoSkJbpSE8yp0an/l3n+WxR+9Gc7tcuHYrhU3bWbvtQu6/68tkusd46oF7+f53HsfpjvCde3aBpuM5LcxQJ+VbGJ6GwMVT6q9xmE82r1lh4wVjKIZFudKm2RFU5gJULUDPdGl5NS67bCelnIq3NMVwNsUPH3uSowstZpsh09UuhpGlUu1QKhUJQkGIQNU18vk8qqpSrVZ7ixKJAdKDEMVWIafh1hZZW1R45IHH+exnPklhaBsf/hdX85ffeoAjrsKf/PU3+N49P6BoZdAUHZnS8T0LGRqRv7PbZcNIgbzmoXsaWgi6KvCDIFqRF2mkDJiZOUkQRmlCpIySNlar1bhXaKAIE13N4DqRCpLEJQz96HORYXR8jJHRYbqOz+SJWVxXIQwNQj2HJ01QUwjFJAwEgQ+6ruH5HSDAcVtRdl0Z9YxDqREKCx+LWlewVG/Sdn1yhSymEYJsIcIGgQKhouKjEggDX0ZboKr4QqftCVwUMBSMrI4qWvjSwVMEoVBImRqehMWlJWYXKmh6mrnZKr6rc+EF2/mJ7ZdSq5ZRFJfCcBbP9zk+M0nTkRhWlnqljSl0LODBe79Nu7pIt1mnmMtyySWXYFkW84tRdJ4fBpi2het7+F6Iphr4nsDQ8oS+haWPEngmnqMhQw3DsOIR29snwfcl4AEp5cXAZcBLwM3Aw1LKrcDD8XuAXwC2xtungb94MxU0Gg3m5uaYmZmhXC6zdevWqMegRU80TUv85kRvwWA5kgyS+XweRVEi7ce4x5FOp0lSHSSRQLVaDdO2QFXYuu0iLMuiWq3S6XRodTtRb0EIBNGq/VCuQCGdJW1YdOpN8AIqlQqPP/44R49O4HSjbJVCCMrlMq7rUiqVaDQa5HI5fN+PIjhMk3Xr1tFsNrnyyivJ5/O9Yd7UyTJSSrZs2cLevXspl5fQNIXnnnuObA4mjk3SaQd0uh6tto8iIs1KhN6bf6vX6wRBwOys03OwPhOWx1knvcXlK6GWZTEyNEKxWGT79m2oQlKtVvEdl6WlRYr5HI7jMD09je/7PP3000gpe+F/Z8LybKnL9QBMXWfnzp3UajXaTpdUOh3N66LGEUo5atU6k8enSKVSbNq0iTVr1pz226+nSRmGYS8FTbSS3en9/6TdVatVFEVhw5oxfu2TN7H76WfZs+9lvn7PE3zvsf24gY9uGPhe1BNLEtY5jkO73Y5XjQu9ENVkXjhJT5LMJSYGPfFjTaYZqtUqU1NTtFqt3ur568HzPLK5DGNjI1iWweLiYk9d/kyIdG31XmBCMr+5XLvUdd1e3aZpnnadXn2tXp0nK9HUSBaPlidtTPQXdF2n2Wxi2zabN2/u+ZZalsXIyAi+79Nutzl06BUmJyd7rmyZ9Cm+Sex+t9vtzS8LIZicnMTzPK699tre/ZZMgyRckozD7Xa7Ny+dREMt12A4V7yhMRVC5ICfAf4qPkGulLIKXAfcGR92J/DRuHwd8DcywlNAQQixhrNAURUajQau67Jt2zaazSYTExPU600mJiap15qkUmm6HZdUKkP7DFkEE8NZKBQYHR3tiRw0m81eEq5EH9K2bXKlIkvVKqWhIdK5LLlCnpm5WZbqNdTYHUWR4LQ7dBpNupU688eneHnvAcpTMyydnMU0UrzyygTdroNpWgihAoJWq4VhGExPT2PbNo7j0Gq1Tgvty+fz1Ot10uk069ev58Ybb0RVYHJykkOHDkW6k5k0ofQYGy+yY8cWdj/1HPWGy5GjJ3n+hYOks8NUql0y2ZHeQ8I0Te6//37GxqKkYa+H5PhkGAinDFJiTJeWlrj77rupL5UJPJe0ZVKtlBkbGWapHCVEO378OAcOHGB+fp5Wq0s2+/qrosvFVk67KV2Pyy+9jKWlJTRDB12l03EIAkmn7dJudchm86TTWTKZDF/84heZn58/7beTm/tM6a09zyOTyWDb0dC/2WyedqymaXQ6Ha5850XMzUyxe89evv7g45SFTlPPEKoqHS+I1J7CyPuk3YhSP6uqSi6Xe410X/JwS4I/KpUKruv2ch8tdyTfsGED4+PjzM7OMjc3d1ZtTcvScN0uQegzPj5KoZih67Qpl8vUarXXCDsnrm9R/jOtZ4iSIINqtUqtVsMwjMgR33ht1tbThHCWCaok/yFSYIo4L0+Z3Gg0em1fVVXmFsocPXoUz/NIpVKcPHmSe+5/kH379jE6OoptR65PhUKBbDbL+vXre8dYhNcAAAXeSURBVOc0yeMWpbs2ew8d3/exbZtdu3Zxww03RHPCisLCwgInZ2Z63hJJh2Z5ZNXyFCZJ/qhzgTib6jqAEOJy4HbgRaJe6R7gc8BJKWVh2XEVKWVRCHEf8F+llLvi/Q8DvyulfOZVv/tpop4rwA5g/zn/m5XDMLDYbxKvwmrjNOBzdqw2PrD6OK02PtuklP9gH6k3swClAVcAvyml3C2E+BKnhvRnwpnUh19jsaWUtxMZaYQQz0gp3/0muLwtWG18YPVxGvA5O1YbH1h9nFYjn3P5/puZM50CpqSUu+P33yYyrnPJ8D1+nV92/AXLvr8emD4XkgMMMMAAqx1vaEyllLPACSHEtnjXzxMN+b8L/Gq871eBe+Pyd4FPxKv6VwE1KeW561sNMMAAA6xivFk/098E/lYIYQBHgV8jMsTfFEL8BjAJ3BAf+33gGuAI0I6PfSPc/lZIvw1YbXxg9XEa8Dk7VhsfWH2c/lHxecMFqAEGGGCAAd4YqyKcdIABBhjg/3f03ZgKIT4shDgUR0ydzUtgJeu8QwgxL4TYv2zfikV0/QP4XCCEeCSOLjsghPhcPzkJISwhxNNCiBdiPrfE+zcLIXbHfL4RT/sghDDj90fizzetJJ9lvFQhxHOx+91q4DMhhNgnhHg+WQnuczs6r5GKb5HLtvi8JFtdCPFbfT4//z5uz/uFEHfF7Xzl2tByh9y3ewNU4BVgC5HG8wvAJW9DvT9D5JGwf9m+/wbcHJdvBm6Ny9cA/5vI5esqYPd54LMGuCIuZ4HDwCX94hT/biYu68DuuJ5vAh+L938Z+Exc/izw5bj8MeAb5+m6/Tbwd8B98ft+85kAhl+1r5/t6E7gU3HZAAr95LOMlwrMAhv72KbXAccAe1nb+eRKtqHzcvLewh98D/DgsvefBz7/NtW9idON6SFgTVxeAxyKy18BPn6m484jt3uBD64GTkAKeBb4KSIHa+3V1w54EHhPXNbi48QK81hPFLb8fuC++KbrG5/4tyd4rTHtyzUDcrGxEKuBz6s4/FPgiT6fn3XACaAUt4n7gA+tZBvq9zA/+YMJpuJ9/cCYjF244tfReP/byjEeTuwk6g32jVM8pH6eyH/4IaIRRFVK6Z+hzh6f+PMaMLSSfIA/BX6HU4oUQ33mA1Ewyg+EEHtEFNEH/btmW4AF4GvxVMhXhRDpPvJZjo8Bd8XlvvCRUp4E/pjI82iGqE3sYQXbUL+N6ZuKluoz3jaOQogM8PfAb0kpzxYsfN45SSkDKeXlRD3CK4HtZ6nzvPIRQvxzYF5KuWf57n7xWYarpZRXEIn7/BshxNlSXJ5vTkmk4l9IKXcCLVYgUvFcEc9BXgt8640OPZ984rnZ64DNwFogTXTdXq/Ot8yn38Z0NUVL9TWiSwihExnSv5VS3r0aOAHISNTmR0TzWAUhROKbvLzOHp/48zywtII0rgauFUJMAF8nGur/aR/5ACClnI5f54HvED10+nXNVmuk4i8Az0op5+L3/eLzAeCYlHJBSukBdwPvZQXbUL+N6Y+BrfGKmkE0HPhun7j0LaJLCCGIVLleklL+935zEkKMCCEKcdkmaogvAY8A178On4Tn9cAPZTzZtBKQUn5eSrleSrmJqI38UEp5U7/4AAgh0kKIbFImmhfcT5+umVy9kYof59QQP6m3H3wmgauEEKn4fkvOz8q1ofMx4fwWJ4avIVq9fgX4z29TnXcRzZt4RE+g3yCaD3kYeDl+LcXHCuDPY377gHefBz4/TTSE2As8H2/X9IsTcCnwXMxnP/Bf4v1bgKeJotu+BZjxfit+fyT+fMt5vHbv49Rqft/4xHW/EG8Hkrbb53Z0OfBMfN3uAYp95pMCykB+2b5+8rkFOBi36f8FmCvZhgYRUAMMMMAAK4B+D/MHGGCAAf5RYGBMBxhggAFWAANjOsAAAwywAhgY0wEGGGCAFcDAmA4wwAADrAAGxnSAAQYYYAUwMKYDDDDAACuAgTEdYIABBlgB/D/m8yc/okaD6gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## START CODE HERE ##\n",
    "#my_image = \"mao.jpg\" # change this to the name of your image file \n",
    "my_image = \"tree.jpg\"\n",
    "#my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat)\n",
    "## END CODE HERE ##\n",
    " \n",
    "fname = \"img/\" + my_image\n",
    "#image = np.array(plt.imread(fname))\n",
    "image = plt.imread(fname)\n",
    "#image = np.array(Image.open(fname))\n",
    "print(num_px)\n",
    "print(image.shape)\n",
    "my_image = np.array(Image.fromarray(image).resize((num_px,num_px))).reshape((1, num_px * num_px * 3)).T\n",
    "print(my_image.shape)\n",
    "my_predicted_image = predict(d[\"w\"], d[\"b\"], my_image)\n",
    " \n",
    "plt.imshow(image)\n",
    "print(\"y = \" + str(np.squeeze(my_predicted_image)) + \", your algorithm predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
